1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Sección 8 - Más Cómodo]

2
00:00:02,610 --> 00:00:04,910
[Rob Bowden - Harvard University]

3
00:00:04,910 --> 00:00:07,070
[Esta es CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> Estas notas de la sección semanas van a ser muy breve,

5
00:00:14,160 --> 00:00:19,070
así que sólo voy a seguir hablando, ustedes van a seguir haciendo preguntas,

6
00:00:19,070 --> 00:00:22,720
y vamos a tratar de llenar el tiempo tanto como sea posible.

7
00:00:22,720 --> 00:00:31,950
Mucha gente piensa que este conjunto de procesadores no es necesariamente difícil, pero es muy largo.

8
00:00:31,950 --> 00:00:37,070
La especificación conjunto de procesadores se toma una hora para leer.

9
00:00:40,530 --> 00:00:45,730
Le damos una gran parte del SQL que pueda necesitar para su uso.

10
00:00:45,730 --> 00:00:50,520
Le guiará a través de una gran cantidad de la misma, por lo que no debe ser demasiado malo.

11
00:00:50,520 --> 00:00:54,560
¿Alguien ha comenzado o terminado?

12
00:00:55,380 --> 00:00:59,710
Es el conjunto de procesadores pasado. Oh, Dios mío.

13
00:00:59,710 --> 00:01:05,400
Por lo general, hay un JavaScript, uno tras esto, pero las cosas cambian calendario

14
00:01:05,400 --> 00:01:09,560
hace que todo sea una semana más corta, y ya no tenemos un conjunto de procesadores JavaScript.

15
00:01:09,560 --> 00:01:12,310
No sé cómo eso afecta si JavaScript se va a aparecer en el examen

16
00:01:12,310 --> 00:01:15,510
o Cuestionario 1.

17
00:01:15,510 --> 00:01:22,260
Me imagino que será algo parecido a lo que necesita saber cosas de alto nivel acerca de JavaScript,

18
00:01:22,260 --> 00:01:26,460
pero dudo que acababa de darle directamente el código JavaScript

19
00:01:26,460 --> 00:01:28,720
ya que no han tenido un conjunto de procesadores en el mismo.

20
00:01:28,720 --> 00:01:33,000
Pero eso será materia para el examen pregunta de la semana que viene.

21
00:01:33,000 --> 00:01:36,320
>> Sección de preguntas.

22
00:01:36,320 --> 00:01:43,870
Muchas de estas cosas son un poco mal redactado, pero vamos a discutir por qué.

23
00:01:43,870 --> 00:01:50,220
A diferencia de C, PHP es un "tipo dinámico" del lenguaje. ¿Qué quiere decir esto, te preguntarás?

24
00:01:50,220 --> 00:01:53,830
Bueno, decir adiós a todos aquellos flotador char, int, y las palabras clave que usted necesita utilizar

25
00:01:53,830 --> 00:01:56,190
al declarar variables y funciones en C.

26
00:01:56,190 --> 00:02:00,420
En PHP, el tipo de una variable se determina por el valor que se está llevando a cabo actualmente.

27
00:02:00,420 --> 00:02:04,990
Así que antes de escribir el código en un archivo llamado dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP es tipado dinámico. Esto es cierto.

29
00:02:12,670 --> 00:02:17,590
Estoy en desacuerdo con el hecho de que eso significa que estamos diciendo adiós a char, float, int,

30
00:02:17,590 --> 00:02:20,620
y otras palabras clave.

31
00:02:20,620 --> 00:02:25,510
La diferencia exacta entre los tipos dinámicos y la alternativa,

32
00:02:25,510 --> 00:02:32,010
que es estático de tipos, es que el tipado dinámico, toda la comprobación de tipos y otras cosas

33
00:02:32,010 --> 00:02:37,350
ocurre en tiempo de ejecución, mientras estático de tipos ocurre en tiempo de compilación.

34
00:02:37,350 --> 00:02:43,030
La palabra estática en general parece tener significados tiempo de compilación.

35
00:02:43,030 --> 00:02:48,170
Supongo que hay otros usos para ella, pero en C cuando se declara una variable estática,

36
00:02:48,170 --> 00:02:52,650
su almacenamiento se asigna en tiempo de compilación.

37
00:02:52,650 --> 00:02:59,260
Aquí, tipado dinámico sólo significa que -

38
00:02:59,260 --> 00:03:04,350
En C si intenta agregar una cadena y un entero, cuando se compila,

39
00:03:04,350 --> 00:03:11,000
se va a quejar porque va a decir que no se puede agregar un entero y un puntero.

40
00:03:11,000 --> 00:03:14,710
No es sólo una operación válida.

41
00:03:14,710 --> 00:03:21,170
Esa es otra cosa que vamos a llegar a en un segundo.

42
00:03:21,170 --> 00:03:24,860
Pero ese tipo de control, el hecho de que se queja en tiempo de compilación,

43
00:03:24,860 --> 00:03:29,220
es la comprobación de tipos estáticos.

44
00:03:29,220 --> 00:03:35,220
Hay lenguas en las que no necesito decir flotador char, int, y todas esas cosas,

45
00:03:35,220 --> 00:03:40,940
pero el lenguaje puede decir del contexto de lo que tipo se supone que debe ser,

46
00:03:40,940 --> 00:03:43,980
pero sigue siendo estático de tipos.

47
00:03:43,980 --> 00:03:49,000
Así que si usted toma 51, OCaml, no es necesario utilizar ninguno de estos tipos,

48
00:03:49,000 --> 00:03:58,700
pero seguirá en tiempo de compilación dice que no puede hacerlo porque va a mezclar un entero y una cadena.

49
00:03:58,700 --> 00:04:05,650
Tipos dinámicos sólo significa que en algún momento durante el tiempo de ejecución que va a conseguir una queja.

50
00:04:05,650 --> 00:04:13,430
Si también ha utilizado Java antes, en general, casi cualquier lenguaje de tipo C

51
00:04:13,430 --> 00:04:20,070
va a ser estático de tipos, por lo que C, C + +, Java, todos los que son generalmente estático de tipos.

52
00:04:20,070 --> 00:04:22,910
En Java al compilar algo y estás diciendo

53
00:04:22,910 --> 00:04:26,670
cadena s es igual a algo nuevo que no es una cadena,

54
00:04:26,670 --> 00:04:28,950
eso va a quejar porque esos tipos simplemente no coinciden.

55
00:04:28,950 --> 00:04:31,180
Eso va a quejar en tiempo de compilación.

56
00:04:31,180 --> 00:04:36,750
Pero también tiene algo de tiempo dinámico cosas como si trata de lanzar algo

57
00:04:36,750 --> 00:04:40,500
a un tipo que es más específico que el tipo actual,

58
00:04:40,500 --> 00:04:45,610
no hay nada que puede hacer en tiempo de compilación para comprobar si ese reparto va a tener éxito.

59
00:04:45,610 --> 00:04:51,130
Java también tiene algún tipo dinámico comprobar que tan pronto como se pone a la línea de código

60
00:04:51,130 --> 00:04:54,130
cuando en realidad está ejecutando, que va a hacer el reparto,

61
00:04:54,130 --> 00:04:56,260
asegurarse de que ese reparto era válido, en primer lugar,

62
00:04:56,260 --> 00:04:59,890
y si no lo era, entonces va a quejarse de que usted tiene un tipo no válido.

63
00:04:59,890 --> 00:05:03,200
Tipo dinámico de cheques.

64
00:05:03,200 --> 00:05:07,010
Escribe esto en un archivo llamado dynamic.php.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
Voy a descomprimir ese formato.

67
00:05:18,750 --> 00:05:21,880
Tenemos una variable, lo establecido en el entero 7,

68
00:05:21,880 --> 00:05:27,930
entonces vamos a imprimirlo y% s -

69
00:05:27,930 --> 00:05:32,830
Oh, estamos imprimiendo el tipo de la misma, por lo que gettype va a devolver el tipo de la variable.

70
00:05:32,830 --> 00:05:35,720
Sólo estamos imprimiendo el tipo una y otra vez.

71
00:05:35,720 --> 00:05:39,440
Acabamos de php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Veremos que cambia de número entero a cadena a Boolean como los que pasamos.

73
00:05:45,920 --> 00:05:54,590
En C no hay ningún tipo de datos Boolean, no hay ningún tipo de datos de cadena.

74
00:05:54,590 --> 00:06:00,500
Hay char * y booleanos sólo tiende a ser int o char o algo así.

75
00:06:00,500 --> 00:06:05,690
En PHP estos tipos existen, y esa es una de las grandes ventajas de PHP más de C -

76
00:06:05,690 --> 00:06:13,290
que las operaciones de cadenas son infinitamente más fácil en PHP que C. Sólo trabajan.

77
00:06:13,290 --> 00:06:18,290
>> Así que volver aquí.

78
00:06:18,290 --> 00:06:21,260
Corrimos dynamic.php.

79
00:06:21,260 --> 00:06:26,710
Esto le dice al intérprete de PHP, llamado php, para ejecutar el código PHP en dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Si usted tiene cualquier error en el archivo, el intérprete le dirá!

81
00:06:30,250 --> 00:06:39,110
El intérprete, esta es otra gran diferencia entre PHP y C.

82
00:06:39,110 --> 00:06:48,200
En C hay que compilar algo y luego ejecutar ese archivo compilado.

83
00:06:48,200 --> 00:06:50,490
En PHP no compila nada.

84
00:06:50,490 --> 00:06:57,200
Así que el intérprete PHP es básicamente leyendo esta línea por línea.

85
00:06:57,200 --> 00:07:02,900
Se realiza var = 7 entonces se realiza printf entonces se realiza var entonces se realiza printf y así sucesivamente.

86
00:07:02,900 --> 00:07:10,910
Hay un poco de compilar lo hace, y lo almacena en caché los resultados

87
00:07:10,910 --> 00:07:15,510
por lo que si se ejecuta el script más tarde que puede hacer algo,

88
00:07:15,510 --> 00:07:19,280
pero básicamente se trata de una línea por línea especie de cosa.

89
00:07:19,280 --> 00:07:25,280
Esto significa que muchas de las optimizaciones que obtenemos en C,

90
00:07:25,280 --> 00:07:31,920
como la compilación, es sólo en general el compilador puede hacer un montón de trucos para ti.

91
00:07:31,920 --> 00:07:36,110
Puede llevar a cabo las variables utilizadas, se puede hacer todo este tipo de cosas,

92
00:07:36,110 --> 00:07:38,660
que puede hacer la recursión de cola.

93
00:07:38,660 --> 00:07:42,550
En PHP no vas a conseguir esa ventaja

94
00:07:42,550 --> 00:07:45,690
porque sólo va a comenzar a ejecutar línea por línea por línea,

95
00:07:45,690 --> 00:07:49,950
y que en realidad no reconocer estas cosas tan fácilmente

96
00:07:49,950 --> 00:07:54,440
ya que no es un paso de gran compilación sobre la cosa y la ejecución;

97
00:07:54,440 --> 00:07:56,860
es sólo línea por línea.

98
00:08:00,730 --> 00:08:02,750
Así que ese es el intérprete.

99
00:08:02,750 --> 00:08:06,840
>> De vuelta a nuestro tipado dinámico: muy bien, ¿eh?

100
00:08:06,840 --> 00:08:08,640
Definitivamente no podía hacer eso en C!

101
00:08:08,640 --> 00:08:11,860
Ahora, a ver si se puede averiguar el tipo de cada uno de los siguientes valores.

102
00:08:11,860 --> 00:08:14,760
Ver la referencia.

103
00:08:14,760 --> 00:08:19,420
Así 3,50. ¿Qué tipo crees que va a ser?

104
00:08:24,480 --> 00:08:26,370
Estos son los tipos que tenemos.

105
00:08:26,370 --> 00:08:30,430
Tenemos Bools, enteros, puntos flotantes, cadenas, matrices, objetos,

106
00:08:30,430 --> 00:08:38,370
y recursos, a continuación, que es una especie de vago.

107
00:08:38,370 --> 00:08:41,010
Creo que en realidad es un ejemplo aquí.

108
00:08:41,010 --> 00:08:43,740
Luego está NULL. NULL es un tipo especial.

109
00:08:43,740 --> 00:08:47,140
A diferencia de C, donde NULL es un puntero con la dirección 0,

110
00:08:47,140 --> 00:08:54,930
en PHP, NULL es su propio tipo donde lo único válido de ese tipo es NULL.

111
00:08:57,560 --> 00:09:00,670
Esto es mucho más útil para la comprobación de errores.

112
00:09:00,670 --> 00:09:04,310
En C, donde tuvimos este problema en el que si regresa NULL,

113
00:09:04,310 --> 00:09:08,660
¿significa que usted está devolviendo un puntero NULL o utilizando NULL para indicar error

114
00:09:08,660 --> 00:09:12,380
o toda la confusión que había en un punto.

115
00:09:12,380 --> 00:09:18,440
En este caso, devuelva NULL significa generalmente error.

116
00:09:20,860 --> 00:09:27,300
Un montón de cosas también devolverá false para el error.

117
00:09:27,300 --> 00:09:33,140
Pero el punto es el tipo NULL, lo único del tipo NULL es NULL.

118
00:09:33,140 --> 00:09:40,090
Luego de devolución de llamada es como se puede definir algunas funciones anónimas.

119
00:09:40,090 --> 00:09:46,420
Usted no tiene que proveer la función de un nombre, pero usted no tendrá que lidiar con eso aquí.

120
00:09:46,420 --> 00:09:53,940
En cuanto a los tipos que no esperes que sepamos,

121
00:09:53,940 --> 00:09:59,000
¿Qué te parece el tipo de 3,50 es? >> [Estudiante] Float.

122
00:09:59,000 --> 00:10:00,370
Si.

123
00:10:00,370 --> 00:10:06,290
Así que aquí, ¿qué te parece el tipo de que es esto? >> [Estudiante] Array.

124
00:10:06,290 --> 00:10:09,890
Si. La primera fue flotador, el segundo es una matriz.

125
00:10:09,890 --> 00:10:14,500
Tenga en cuenta que esta serie no es como una matriz C

126
00:10:14,500 --> 00:10:19,610
donde usted tiene el índice 0 tiene algún valor, índice 1 tiene algún valor.

127
00:10:19,610 --> 00:10:26,320
Aquí, los índices son a, b, y c, y los valores son 1, 2, y 3.

128
00:10:26,320 --> 00:10:33,980
En PHP no hay diferencia entre una matriz asociativa y sólo una matriz regular

129
00:10:33,980 --> 00:10:36,740
como se podría pensar de él en C.

130
00:10:36,740 --> 00:10:43,040
No sólo esto, y debajo de la capucha de una matriz regular es una matriz asociativa

131
00:10:43,040 --> 00:10:50,000
donde 0 mapas a algún valor de la misma manera se asigna a un cierto valor.

132
00:10:50,000 --> 00:11:00,410
Por esta razón, PHP puede ser muy malo para realmente rápidos código / evaluación comparativa de las cosas

133
00:11:00,410 --> 00:11:07,930
ya que en C cuando se utiliza una matriz que saber que el acceso a un miembro es la constante de tiempo.

134
00:11:07,930 --> 00:11:11,860
En PHP para acceder a un miembro es quien sabe cuánto tiempo?

135
00:11:11,860 --> 00:11:18,970
Es probable que sea constante si hashes correctamente.

136
00:11:18,970 --> 00:11:21,620
¿Quién sabe lo que está haciendo en realidad por debajo de la capucha?

137
00:11:21,620 --> 00:11:25,600
Usted realmente necesidad de examinar la aplicación para ver cómo va a lidiar con eso.

138
00:11:25,600 --> 00:11:28,550
Entonces fopen.

139
00:11:28,550 --> 00:11:36,420
Creo que aquí vamos a fopen Manual de PHP sólo para mirar el tipo de retorno.

140
00:11:36,420 --> 00:11:41,260
Vemos aquí puedes consultar casi cualquier función en el manual de PHP

141
00:11:41,260 --> 00:11:47,540
y esto es una especie de la página del manual de PHP.

142
00:11:47,540 --> 00:11:51,060
El tipo de cambio se va a requerir muchos recursos.

143
00:11:51,060 --> 00:11:56,050
Es por eso que lo busqué, porque en realidad no definir los recursos.

144
00:11:56,050 --> 00:12:04,110
La idea de los recursos, en C que tiene un tipo de FILE * o lo que sea;

145
00:12:04,110 --> 00:12:07,200
PHP en el recurso es su archivo *.

146
00:12:07,200 --> 00:12:10,360
Es lo que vamos a leer, que es lo que vamos a estar escribiendo.

147
00:12:10,360 --> 00:12:20,710
Por lo general es externa, por lo que es un recurso que puede tirar cosas desde y tirar cosas a.

148
00:12:20,710 --> 00:12:26,520
Y por último, ¿cuál es el tipo de NULL? >> [Estudiante] NULL.

149
00:12:26,520 --> 00:12:30,650
Si. Así que la única cosa que es NULL es NULL.

150
00:12:30,650 --> 00:12:33,480
NULL es NULL.

151
00:12:35,490 --> 00:12:41,170
>> Una característica del sistema de tipos de PHP (para bien o para mal) es su capacidad de hacer malabares con los tipos.

152
00:12:41,170 --> 00:12:44,390
Al escribir una línea de código PHP que combina los valores de diferentes tipos,

153
00:12:44,390 --> 00:12:46,670
PHP intentará hacer lo más sensato.

154
00:12:46,670 --> 00:12:48,920
Pruebe cada una de las siguientes líneas de código PHP. ¿Qué está impreso?

155
00:12:48,920 --> 00:12:51,000
¿Es lo que esperabas? ¿Por qué o por qué no?

156
00:12:51,000 --> 00:12:58,600
Este hecho acerca de PHP es lo que lo hace ser lo que llamamos tipos débiles.

157
00:12:58,600 --> 00:13:04,610
Tipos débiles y fuertemente tipado,

158
00:13:04,610 --> 00:13:06,840
existen diferentes aplicaciones de estos términos,

159
00:13:06,840 --> 00:13:12,020
pero la mayoría de la gente usa tipos débiles y fuertemente tipado en el sentido de este tipo de cosas

160
00:13:12,020 --> 00:13:15,920
donde ("1" + 2), que funciona.

161
00:13:15,920 --> 00:13:18,290
En C que no iba a funcionar.

162
00:13:18,290 --> 00:13:22,490
Usted puede imaginar esto no funciona.

163
00:13:22,490 --> 00:13:29,200
Muchas personas mezclan tipado dinámico y tipificación débil y tipos estáticos y tipado fuerte.

164
00:13:29,200 --> 00:13:34,050
Python es un ejemplo más de un idioma que se escribe de forma dinámica.

165
00:13:34,050 --> 00:13:41,770
Usted puede lanzar en torno a los tipos de las variables y que va a determinar en tiempo de ejecución

166
00:13:41,770 --> 00:13:44,680
las comprobaciones de error.

167
00:13:44,680 --> 00:13:50,740
En Python se va a ejecutar esto y verá ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
y se producirá un error, ya que dice que no se puede agregar una cadena y un entero.

169
00:13:55,920 --> 00:14:00,860
En PHP, que es igual de tipado dinámico, esto no va a fallar.

170
00:14:00,860 --> 00:14:04,220
Tipificación débil tiene que ver con el hecho de que hace cosas con tipos

171
00:14:04,220 --> 00:14:07,800
que en realidad no tiene sentido necesariamente.

172
00:14:07,800 --> 00:14:17,420
Así ("1" + 2), puedo imaginar que siendo la cadena 12, me imagino que es la cadena 3,

173
00:14:17,420 --> 00:14:20,710
Me imagino que es el número entero 3.

174
00:14:20,710 --> 00:14:24,530
No es necesariamente bien definida, y probablemente vamos a ver aquí

175
00:14:24,530 --> 00:14:29,140
que al imprimir ("1" + 2), que probablemente va a terminar siendo diferente

176
00:14:29,140 --> 00:14:32,320
de impresión (1 + "2").

177
00:14:32,320 --> 00:14:39,700
Y esto tiende a ser, en mi opinión, para peor.

178
00:14:39,700 --> 00:14:44,240
Aquí podemos tratar estos.

179
00:14:44,240 --> 00:14:48,740
Otro pequeño truco acerca de PHP es que no es necesario escribir realmente el archivo.

180
00:14:48,740 --> 00:14:52,790
Sin haber corrido este modo de comando.

181
00:14:52,790 --> 00:14:57,710
Así php-r, entonces podemos tirar la orden aquí:

182
00:14:57,710 --> 00:15:06,610
"Print ('1 '+ 2)," y voy a lanzar una nueva línea.

183
00:15:19,550 --> 00:15:23,970
Este impreso 3.

184
00:15:31,100 --> 00:15:35,330
Parece que imprime 3 y es el número entero 3.

185
00:15:35,330 --> 00:15:38,420
Así que ahora vamos a tratar al revés:

186
00:15:38,420 --> 00:15:42,970
"Letra (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
Tenemos 3, y lo está también va a ser un número entero 3? Honestamente, no tengo idea.

188
00:15:50,490 --> 00:15:54,030
Parece que es consistente.

189
00:15:54,030 --> 00:15:59,550
Nunca hay alguna posibilidad de que sea el 12 cuerdas ni nada de eso

190
00:15:59,550 --> 00:16:08,080
PHP porque, a diferencia de JavaScript y Java también,

191
00:16:08,080 --> 00:16:11,670
tiene un operador independiente para la concatenación.

192
00:16:11,670 --> 00:16:14,930
Concatenación en PHP es punto.

193
00:16:14,930 --> 00:16:22,950
Así impresión (1 '2 '.); Nos va a dar 12.

194
00:16:25,790 --> 00:16:32,420
Esto tiende a crear confusión donde la gente trata de hacer algo como str + =

195
00:16:32,420 --> 00:16:37,840
otra cosa que desee agregar a la final de la cadena, y eso va a fracasar.

196
00:16:37,840 --> 00:16:40,770
Que tiene que hacer str. =

197
00:16:42,000 --> 00:16:46,240
Así que no te olvides de concatenación en PHP es un punto.

198
00:16:46,240 --> 00:16:52,100
Otras cosas para intentar: print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Ya te he dicho que no hay esperanza de que ello implique CS50

200
00:17:03,610 --> 00:17:06,119
desde concatenación no es +.

201
00:17:06,119 --> 00:17:08,440
¿Qué te parece que esto va a terminar siendo?

202
00:17:10,359 --> 00:17:13,460
Sinceramente, no tienen absolutamente ninguna idea.

203
00:17:14,250 --> 00:17:16,460
Parece que es sólo 50.

204
00:17:16,460 --> 00:17:21,490
Ve a la cuerda, y yo apuesto a que si ponemos 123CS -

205
00:17:21,490 --> 00:17:29,640
Ve a la primera cadena, se trata de leer un número entero de ella o de un número de la misma.

206
00:17:29,640 --> 00:17:31,710
En este caso se ve 123CS.

207
00:17:31,710 --> 00:17:35,190
"Eso no tiene sentido como un entero, así que sólo voy a pensar en 123".

208
00:17:35,190 --> 00:17:38,580
Así 123 + 50 va a ser 173.

209
00:17:38,580 --> 00:17:40,740
Y aquí comienza a leer esto como un entero.

210
00:17:40,740 --> 00:17:45,690
No se ve nada, por lo que sólo lo trata como 0. Entonces, 0 + 50 va a ser 50.

211
00:17:45,690 --> 00:17:51,600
Esto que estoy asumiendo que va a hacer algo similar.

212
00:17:51,600 --> 00:17:54,310
Estoy pensando en 99.

213
00:17:54,310 --> 00:17:57,580
Sí, porque va a tomar la primera -

214
00:18:12,880 --> 00:18:15,730
Así 99.

215
00:18:15,730 --> 00:18:21,970
Aquí (10/7), si esto fuera C, ¿cuál sería volver?

216
00:18:23,700 --> 00:18:29,630
[Estudiante] 1. >> Sí, sería una causa 10/7 está dividiendo dos números enteros.

217
00:18:29,630 --> 00:18:32,910
Entero dividido por un entero va a devolver un entero.

218
00:18:32,910 --> 00:18:37,750
No se puede volver un punto cualquiera que sea, por lo que sólo va a devolver 1.

219
00:18:37,750 --> 00:18:46,120
Aquí impresión (10/7), que va a interpretar en realidad eso.

220
00:18:46,120 --> 00:18:53,760
Y esto significa que si usted realmente quiere hacer redondeo entero y cosas por el estilo,

221
00:18:53,760 --> 00:18:59,950
que tiene que hacer print (piso (10/7));

222
00:18:59,950 --> 00:19:08,460
En C es probablemente raro que usted puede confiar en el truncamiento entero con regularidad,

223
00:19:08,460 --> 00:19:12,260
pero en PHP no se puede porque automáticamente se convertirá en un flotador.

224
00:19:13,430 --> 00:19:17,610
Y entonces (7 + true); ¿qué te parece que va a ser?

225
00:19:18,550 --> 00:19:23,640
Supongo 8 si se va a interpretar como una verdad.

226
00:19:23,640 --> 00:19:25,740
Parece que son las 8.

227
00:19:25,740 --> 00:19:31,710
>> Así que todo lo que hemos hecho en los últimos 10 minutos no debe absolutamente hacer.

228
00:19:31,710 --> 00:19:39,870
Verá el código que hace esto.

229
00:19:39,870 --> 00:19:42,700
No tiene por qué ser tan sencillo como este.

230
00:19:42,700 --> 00:19:47,240
Usted podría tener dos variables, y 1 variable pasa a ser una cadena

231
00:19:47,240 --> 00:19:51,310
y la otra variable pasa a ser un int, y luego se añaden estas variables.

232
00:19:51,310 --> 00:20:00,120
A partir de PHP es tipado dinámico y no va a hacer ninguna comprobación de tipo para usted

233
00:20:00,120 --> 00:20:03,640
Y puesto que es tipos débiles y como se acaba de lanzar automáticamente estas cosas juntas

234
00:20:03,640 --> 00:20:11,490
y todo se va a trabajar, es difícil saber hasta que esta variable debe ser una cadena ahora,

235
00:20:11,490 --> 00:20:14,930
por lo que no debe añadir a esta variable, que es un entero.

236
00:20:18,780 --> 00:20:24,560
La mejor práctica es si una variable es una cadena, se mantendrá como una cadena para siempre.

237
00:20:24,560 --> 00:20:26,980
Si una variable es un entero, mantenerlo como un int para siempre.

238
00:20:26,980 --> 00:20:30,770
Si usted quiere tratar con números enteros y cadenas,

239
00:20:30,770 --> 00:20:36,970
puede utilizar varsint - eso es JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Lo hago todo el tiempo. PHP y JavaScript mezclo todo.

241
00:20:42,520 --> 00:20:47,600
Así intval va a devolver el valor entero de una variable.

242
00:20:47,600 --> 00:20:56,550
Si pasamos en "print (intval ('123 ')), se obtiene 123.

243
00:21:06,820 --> 00:21:15,850
Intval sí mismo no va a hacer el cheque para nosotros que es exclusivamente un entero.

244
00:21:15,850 --> 00:21:20,460
El manual de PHP, hay funciones sólo disponibles para muchos,

245
00:21:20,460 --> 00:21:26,560
asique creo que lo que yo usaría es is_numeric primero.

246
00:21:26,560 --> 00:21:32,590
Supongo que devuelve false.

247
00:21:32,590 --> 00:21:35,780
Esa es otra cosa que tenemos que ir más es. ===

248
00:21:37,850 --> 00:21:44,020
Así is_numeric ('123df '), no se le ocurriría que a medida que is_numeric.

249
00:21:44,020 --> 00:21:46,720
En C tendrías que iterar sobre todos los caracteres

250
00:21:46,720 --> 00:21:50,410
y comprobar para ver si cada carácter es el dígito o lo que sea.

251
00:21:50,410 --> 00:21:53,850
Aquí is_numeric va a hacer eso por nosotros,

252
00:21:53,850 --> 00:21:56,520
y se devuelve false.

253
00:21:56,520 --> 00:22:02,120
Así que cuando me impresa, se imprimirá nada, así que aquí estoy comparando a ver,

254
00:22:02,120 --> 00:22:05,490
se te ha ocurrido que es falsa? Y por lo que ahora se está imprimiendo 1.

255
00:22:05,490 --> 00:22:10,060
Al parecer, se imprime 1 como verdadero lugar de imprimir verdadero como verdadero.

256
00:22:10,060 --> 00:22:15,790
Me pregunto si lo hago print_r. No, todavía lo hace 1.

257
00:22:15,790 --> 00:22:26,760
>> Volviendo a ===, == todavía existe,

258
00:22:26,760 --> 00:22:32,260
y si usted habla con Tommy dirá == está perfectamente bien.

259
00:22:32,260 --> 00:22:37,700
Voy a decir que == es terrible y nunca se debe utilizar. ==

260
00:22:37,700 --> 00:22:44,870
La diferencia es que == compara cosas

261
00:22:44,870 --> 00:22:48,450
donde puede ser cierto incluso si no son del mismo tipo,

262
00:22:48,450 --> 00:22:53,810
mientras === compara las cosas y primero se comprueba que son del mismo tipo?

263
00:22:53,810 --> 00:22:58,010
Sí. Bien, ahora voy a ver si realmente comparar a ser igual.

264
00:22:58,010 --> 00:23:08,890
Usted consigue cosas raras como 10 es igual a - vamos a ver lo que dice.

265
00:23:08,890 --> 00:23:15,570
Así que ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
Esto devuelve true.

267
00:23:17,980 --> 00:23:21,420
¿Alguien tiene alguna idea por qué esto devuelve true?

268
00:23:25,180 --> 00:23:27,120
No se trata sólo de eso. Tal vez esto es una indirecta.

269
00:23:27,120 --> 00:23:33,170
Pero si puedo cambiar eso a un f - es maldito! Sigo usando comillas dobles.

270
00:23:33,170 --> 00:23:38,780
La razón de las comillas dobles están gritando a mí es porque me he puesto esta entre comillas dobles.

271
00:23:38,780 --> 00:23:43,850
Así que podría escapar de las comillas dobles en aquí, pero comillas simples hacen que sea más fácil.

272
00:23:43,850 --> 00:23:49,120
Así que ('10 '== '1 f1'); no se imprime cierto. ('10 '== '1 E1'); imprime cierto.

273
00:23:49,120 --> 00:23:56,330
[Estudiante] ¿Es hexadecimal? >> No es hexagonal, pero casi que es como -

274
00:23:56,330 --> 00:24:01,060
Notación 1e1, científico.

275
00:24:01,060 --> 00:24:07,950
Se reconoce como un 1e1 * 10 ^ 1 o lo que sea.

276
00:24:07,950 --> 00:24:11,510
Esos son números enteros iguales.

277
00:24:11,510 --> 00:24:15,930
Si lo hacemos === entonces va a ser falsa.

278
00:24:15,930 --> 00:24:28,490
En realidad tengo ni idea de si lo hacemos == ¿qué pasa con (10 y ''10abc); Está bien. Así que eso es cierto.

279
00:24:28,490 --> 00:24:35,940
Así como cuando lo hizo (10 + '10abc »), y que sería 20,

280
00:24:35,940 --> 00:24:38,800
aquí (10 '10abc == '); es verdad.

281
00:24:38,800 --> 00:24:45,350
Peor aún son cosas como (falso == NULL); es cierto

282
00:24:45,350 --> 00:24:52,210
o (false == 0); es cierto, (false == []);

283
00:24:52,210 --> 00:25:00,970
Hay casos raros de - Ese es uno de esos casos raros.

284
00:25:00,970 --> 00:25:08,110
Observe que (false == []); es verdad.

285
00:25:08,110 --> 00:25:11,950
('0 '== False); es verdad.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); Es falso.

287
00:25:16,090 --> 00:25:19,090
Así == es de ninguna manera transitiva.

288
00:25:19,090 --> 00:25:26,830
una puede ser igual a B y A puede ser igual a c,

289
00:25:26,830 --> 00:25:29,340
pero b puede no ser igual a c.

290
00:25:29,340 --> 00:25:35,580
Eso es una abominación para mí, y siempre se debe utilizar. ===

291
00:25:35,580 --> 00:25:38,590
[Estudiante] ¿Podemos hacerlo! == También? >> [Bowden] Sí.

292
00:25:38,590 --> 00:25:44,600
El equivalente sería! = Y! ==.

293
00:25:44,600 --> 00:25:48,230
Esto es realmente educado en la especificación de conjunto de procesadores

294
00:25:48,230 --> 00:25:52,000
donde una gran cantidad de funciones devuelven -

295
00:25:52,000 --> 00:25:53,890
El manual de PHP es bueno acerca de esto.

296
00:25:53,890 --> 00:25:59,140
Se pone en una caja roja grande "Esto devolverá false si hay un error."

297
00:25:59,140 --> 00:26:03,940
Pero volviendo 0 es una cosa perfectamente razonable para volver.

298
00:26:03,940 --> 00:26:08,250
Piense en cualquier función que se espera que regrese un número entero.

299
00:26:11,250 --> 00:26:17,880
Supongamos que esta función debe contar el número de líneas en un archivo o algo.

300
00:26:17,880 --> 00:26:23,490
En circunstancias normales, se pasa a esta función un archivo

301
00:26:23,490 --> 00:26:27,120
y que va a devolver un número entero que representa el número de líneas.

302
00:26:27,120 --> 00:26:30,820
Así que 0 es un número perfectamente razonable si el archivo es sólo vacío.

303
00:26:30,820 --> 00:26:36,810
Pero lo que si se le pasa un archivo no válido y la función pasa a devolver false

304
00:26:36,810 --> 00:26:38,860
si se le pasa un archivo no válido?

305
00:26:38,860 --> 00:26:46,500
Si usted acaba de hacer == no está diferenciando así entre el archivo inválido y archivo vacío.

306
00:26:48,870 --> 00:26:51,350
Utilice siempre. ===

307
00:26:55,690 --> 00:26:58,000
Eso es todo de ellos.

308
00:26:58,000 --> 00:27:01,660
>> En PHP, el tipo de matriz es diferente de lo que estamos acostumbrados en C.

309
00:27:01,660 --> 00:27:06,650
De hecho, es posible que ya han dado cuenta de esto anteriormente, cuando se dio cuenta de que esto es de tipo array.

310
00:27:06,650 --> 00:27:15,640
La sintaxis de soporte es nuevo a partir de PHP 5.4, que es la nueva versión de PHP.

311
00:27:15,640 --> 00:27:36,960
Antes de esto, siempre tenía que escribir array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Ese fue el constructor de una matriz.

313
00:27:41,160 --> 00:27:45,950
Ahora PHP por fin se decidió a la sintaxis agradable de apenas entre corchetes,

314
00:27:45,950 --> 00:27:50,900
que es simplemente mucho mejor que la matriz.

315
00:27:50,900 --> 00:27:54,480
Pero teniendo en cuenta PHP 5.4 es la versión más reciente,

316
00:27:54,480 --> 00:27:59,090
puede encontrar lugares que no tienen ni siquiera PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Durante el verano nos encontramos con este problema en el PHP 5.3 era lo que teníamos en el aparato,

318
00:28:08,220 --> 00:28:14,480
pero el servidor que desplegamos toda nuestra libreta de calificaciones y presentar y todas esas cosas a

319
00:28:14,480 --> 00:28:16,750
PHP fue 5,4.

320
00:28:16,750 --> 00:28:23,060
Sin saber esto, se desarrolló en el 5,3, empujó a 5,4,

321
00:28:23,060 --> 00:28:25,660
y ahora, de repente nada de nuestro código funciona

322
00:28:25,660 --> 00:28:28,680
porque allí pasó a haber sido los cambios entre 5,3 y 5,4

323
00:28:28,680 --> 00:28:31,030
que no son compatibles,

324
00:28:31,030 --> 00:28:35,770
y tenemos que ir a arreglar todas nuestras cosas que no funcionan para PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
Para esta clase, ya que el aparato tiene PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
es perfectamente posible utilizar corchetes.

327
00:28:47,240 --> 00:28:50,440
Pero si usted está mirando las cosas en la Internet,

328
00:28:50,440 --> 00:28:54,880
si usted está buscando algún tipo de material de matriz, más probable es que usted va a ver

329
00:28:54,880 --> 00:29:02,020
el hechizo fuera sintaxis array constructor desde que ha existido desde PHP nació

330
00:29:02,020 --> 00:29:07,340
y la sintaxis de corchetes ha sido durante los últimos dos meses

331
00:29:07,340 --> 00:29:10,020
o cuando se acercó 5,4.

332
00:29:10,020 --> 00:29:12,710
Esta es la forma de índice.

333
00:29:12,710 --> 00:29:30,610
Al igual que en C como lo haría con índice entre corchetes como $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
que el índice de la misma manera si le sucede que tiene sus índices ser cadenas.

335
00:29:36,320 --> 00:29:40,440
Así que $ array ['a'] y $ array ['b'].

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. ¿Por qué sería malo?

337
00:29:52,490 --> 00:29:59,870
Probablemente va a generar una advertencia, pero todavía funcionan. PHP tiende a hacer eso.

338
00:29:59,870 --> 00:30:04,890
Tiende a poco: "Yo te voy a advertir sobre esto, pero yo sólo voy a seguir adelante

339
00:30:04,890 --> 00:30:07,550
"Y hacer todo lo que pueda".

340
00:30:07,550 --> 00:30:11,500
Es probable que traducir esto a una cadena,

341
00:30:11,500 --> 00:30:15,000
pero es posible que en algún momento en el pasado alguien dijo

342
00:30:15,000 --> 00:30:20,180
b definir como 'Hola Mundo'.

343
00:30:20,180 --> 00:30:28,740
Así que ahora b podría ser una constante de matriz y $ [b] en realidad va a hacer 'hola mundo'.

344
00:30:28,740 --> 00:30:32,380
Creo que en este punto, o al menos nuestra configuración de PHP,

345
00:30:32,380 --> 00:30:37,870
si tratas de índice en una matriz y que la clave no existe, se producirá un error.

346
00:30:37,870 --> 00:30:40,150
Yo no creo que sea sólo una advertencia.

347
00:30:40,150 --> 00:30:44,560
O por lo menos usted puede configurarlo para que no sólo te advierto que no sólo hacia arriba.

348
00:30:44,560 --> 00:30:49,290
>> La forma de comprobar si realmente existe tal índice es isset.

349
00:30:49,290 --> 00:30:54,690
Así isset ($ array ['hola mundo']) devuelve falso.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['b']) devuelve verdadero.

351
00:31:06,830 --> 00:31:09,880
Usted puede mezclar estas sintaxis.

352
00:31:15,060 --> 00:31:22,440
Estoy bastante seguro de lo que esta matriz terminaría siendo es - Podemos probarlo.

353
00:31:43,290 --> 00:31:45,700
Oh, necesito PHPWord.

354
00:31:53,960 --> 00:32:00,260
Esto es mezclar la sintaxis donde se especifica cuál es la clave

355
00:32:00,260 --> 00:32:03,330
y no se especifica cuál es la clave.

356
00:32:03,330 --> 00:32:05,520
Así que aquí 3 es un valor.

357
00:32:05,520 --> 00:32:08,080
No ha dicho explícitamente cuál es su clave va a ser.

358
00:32:08,080 --> 00:32:11,670
¿Qué te parece la clave va a ser?

359
00:32:11,670 --> 00:32:21,410
[Estudiante] 0. >> Supongo 0 sólo porque es la primera que no se ha especificado.

360
00:32:21,410 --> 00:32:23,500
De hecho, podemos hacer un par de estos casos.

361
00:32:23,500 --> 00:32:28,030
Así es print_r imprimir recursiva. Se imprimirá toda la matriz.

362
00:32:28,030 --> 00:32:32,700
Sería imprimir submatrices de la matriz si los hubiera.

363
00:32:32,700 --> 00:32:36,630
Así print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
Se parece a ella le daba 0.

365
00:32:38,810 --> 00:32:43,530
De hecho, hay algo a tener en cuenta aquí, pero nos pondremos en contacto con él en un segundo.

366
00:32:43,530 --> 00:32:45,850
Pero lo que si se me ocurre hacer este índice 1?

367
00:32:45,850 --> 00:32:51,170
PHP no hace diferencia entre los índices de cadenas e índices enteros,

368
00:32:51,170 --> 00:33:00,280
lo que en este momento me acaba de definir un índice 1 y puedo hacer las dos cosas array $ [1] y $ array [1 "]

369
00:33:00,280 --> 00:33:06,250
y será el mismo índice y la misma clave.

370
00:33:06,250 --> 00:33:13,000
¿Y ahora qué cree usted que 3 va a ser? >> [Estudiante] 2. >> [Bowden] Estoy adivinando 2.

371
00:33:16,000 --> 00:33:18,690
Si. Son las 2.

372
00:33:18,690 --> 00:33:24,790
¿Qué pasaría si hiciéramos esto es 10, esto es 4? ¿Qué te parece el índice de 3 va a ser?

373
00:33:27,360 --> 00:33:29,110
Estoy pensando en 11.

374
00:33:29,110 --> 00:33:33,060
Mi conjetura en cuanto a lo que hace PHP - y creo que lo he visto antes -

375
00:33:33,060 --> 00:33:39,760
se trata simplemente de un seguimiento de lo que el mayor índice numérico que ha utilizado hasta ahora es.

376
00:33:39,760 --> 00:33:44,230
Nunca va a asignar un índice de la cadena a 3. Siempre será un índice numérico.

377
00:33:44,230 --> 00:33:47,690
Por lo tanto, sigue la pista de la más alta está asignada hasta el momento, que pasa a ser 10,

378
00:33:47,690 --> 00:33:52,540
y que va a dar 11 a 3.

379
00:33:52,540 --> 00:34:02,110
Lo que dije antes, observe la forma en que se está imprimiendo esta matriz.

380
00:34:02,110 --> 00:34:06,850
Imprime clave 10, clave 4, clave 11, tecla d.

381
00:34:06,850 --> 00:34:09,790
Ni siquiera vamos a hacer -

382
00:34:15,760 --> 00:34:22,489
Supongo que no puso un 0, pero es la impresión 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
¿Qué pasa si me cambio aquí? ¿O vamos a cambiar realmente estos 2.

384
00:34:29,330 --> 00:34:31,940
Ahora se imprime 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
Arrays de PHP no son como tu tabla hash regular.

386
00:34:41,270 --> 00:34:45,570
Es perfectamente razonable pensar en ellos como tablas hash 99% de las veces.

387
00:34:45,570 --> 00:34:53,790
Pero en las tablas de hash no tiene sentido del orden en el que las cosas se insertaron.

388
00:34:53,790 --> 00:34:56,639
Así que tan pronto como se inserta en la tabla hash,

389
00:34:56,639 --> 00:35:00,590
asumir que no hay lista enlazada y se podía juzgar dentro de una lista enlazada

390
00:35:00,590 --> 00:35:03,980
que se insertó primero.

391
00:35:03,980 --> 00:35:10,060
Pero aquí insertamos 2 primero y sabe cuando está imprimiendo esta matriz que 2 es lo primero.

392
00:35:10,060 --> 00:35:13,090
No imprimirlo en cualquier orden.

393
00:35:13,090 --> 00:35:17,550
La estructura de datos técnicos que se está utilizando es un mapa ordenado,

394
00:35:17,550 --> 00:35:24,690
por lo que mapea claves a los valores y recuerda el orden en el que las claves se insertan.

395
00:35:24,690 --> 00:35:31,600
Básicamente se trata de que algunas de las complicaciones en las que es realmente molesto -

396
00:35:31,600 --> 00:35:34,510
Digamos que usted tiene una matriz 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
y quiere sacar índice 2.

398
00:35:37,700 --> 00:35:47,750
Una forma de hacerlo, vamos a ver lo que parece.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
Desactivar pasa a desarmar ambas variables e índices de matriz.

401
00:35:54,880 --> 00:35:58,630
Así unset ($ array [2]);

402
00:35:58,630 --> 00:36:03,430
Ahora, ¿qué es esto va a parecer? 2 es sólo pasado, por lo que está perfectamente bien.

403
00:36:03,430 --> 00:36:11,670
Más molesto es que si quieres que las cosas sean realmente como una matriz.

404
00:36:11,670 --> 00:36:14,910
Voy a poner números al azar.

405
00:36:14,910 --> 00:36:20,400
Ahora fíjese en mis índices.

406
00:36:20,400 --> 00:36:26,860
Yo quiero que sea igual que un array C, donde se pasa de 0 a length - 1

407
00:36:26,860 --> 00:36:30,810
y puedo iterar sobre ella como tal.

408
00:36:30,810 --> 00:36:38,520
Pero tan pronto como desarmar el segundo índice, lo que había en el índice 3 no convertido índice 2.

409
00:36:38,520 --> 00:36:44,790
En su lugar, sólo elimina ese índice y ahora te vas 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Esto es perfectamente razonable.

411
00:36:48,740 --> 00:36:53,950
Es sólo una molestia y hay que hacer cosas como empalme matriz. Si.

412
00:36:53,950 --> 00:36:57,200
>> [Estudiante] ¿Qué pasaría si tuvieras un bucle for

413
00:36:57,200 --> 00:36:59,630
y que quería revisar todos los elementos?

414
00:36:59,630 --> 00:37:02,290
Cuando golpeó dos, ¿sería ceder nunca?

415
00:37:02,290 --> 00:37:10,150
Iteración sobre una matriz. Hay dos maneras en que puede hacerlo.

416
00:37:10,150 --> 00:37:12,770
Puede utilizar un bucle for normal.

417
00:37:12,770 --> 00:37:22,000
Esta es otra complejidad de PHP.

418
00:37:22,000 --> 00:37:27,420
La mayoría de los idiomas, yo diría, tener algún tipo de longitud o len o algo

419
00:37:27,420 --> 00:37:30,470
indica la longitud de una matriz.

420
00:37:30,470 --> 00:37:32,820
En PHP es conde.

421
00:37:32,820 --> 00:37:36,160
Así count ($ array); $ i +) +

422
00:37:36,160 --> 00:37:42,950
Vamos a print ($ array [$ i]);

423
00:37:45,920 --> 00:37:48,820
Notice: Undefined offset: 2.

424
00:37:48,820 --> 00:37:51,610
Es sólo va a fallar.

425
00:37:51,610 --> 00:38:03,020
Esta es la razón por la que, en su mayor parte, no es necesario para iterar sobre una matriz de esta manera.

426
00:38:03,020 --> 00:38:07,110
Puede ser que sea una exageración, pero que nunca necesidad de iterar sobre un arreglo como este

427
00:38:07,110 --> 00:38:19,410
debido a que PHP ofrece una sintaxis foreach donde foreach ($ array como $ item).

428
00:38:19,410 --> 00:38:31,830
Ahora bien, si imprimir ($ item); - nos volveremos hablar de ello en un segundo - que funciona perfectamente bien.

429
00:38:31,830 --> 00:38:38,960
La forma en que está trabajando foreach es el primer argumento es la matriz que se está interactuando sobre.

430
00:38:38,960 --> 00:38:44,060
Y el segundo argumento, tema, a través de cada paso del bucle for

431
00:38:44,060 --> 00:38:52,690
que va a tomar el siguiente paso en la matriz. Así que recuerda que la matriz tiene una orden.

432
00:38:52,690 --> 00:38:55,690
La primera vez que el bucle for, el punto va a ser 123

433
00:38:55,690 --> 00:38:59,540
entonces será 12 entonces será 13 entonces será 23 entonces será 213.

434
00:38:59,540 --> 00:39:04,670
Las cosas se ponen realmente extraño cuando haces algo como foreach.

435
00:39:04,670 --> 00:39:07,480
Vamos a ver qué pasa, porque usted nunca debe hacer esto.

436
00:39:07,480 --> 00:39:13,320
¿Qué pasaría si unset ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
Eso probablemente se esperaba.

438
00:39:26,030 --> 00:39:30,950
Estás iterar sobre esta matriz, y cada vez que estés desarmado el primer índice.

439
00:39:30,950 --> 00:39:39,720
Así que para el índice 0, lo primero elemento, toma el valor 0, así que va a ser 123.

440
00:39:39,720 --> 00:39:44,630
Pero dentro del bucle for nos unset índice 1, lo que significa que 12 se han ido.

441
00:39:44,630 --> 00:39:57,480
Así imprimir. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL es solo salto de línea, pero es técnicamente más fáciles de transportar

443
00:40:03,580 --> 00:40:08,890
desde saltos de línea en Windows es diferente de saltos de línea en Mac y UNIX.

444
00:40:08,890 --> 00:40:18,040
En Windows nueva línea es \ r \ n, mientras que en todas partes se tiende para estar \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL está configurado para que utilice cualquiera que sea la nueva línea de su sistema.

446
00:40:25,150 --> 00:40:29,310
Así que imprimir. No hay que print_r ($ array) al final.

447
00:40:32,830 --> 00:40:37,390
No tenía ni idea de que ese sería el comportamiento.

448
00:40:41,740 --> 00:40:48,960
Artículo todavía toma el valor 12 a pesar de que desarmar 12 antes de que alguna vez llegó a él desde la matriz.

449
00:40:52,770 --> 00:40:58,840
No tome mi palabra en esto, pero parece que foreach crea una copia de la matriz

450
00:40:58,840 --> 00:41:02,160
y artículo asume todos los valores de esa copia.

451
00:41:02,160 --> 00:41:07,760
Así que incluso si se modifica la matriz dentro del bucle for,

452
00:41:07,760 --> 00:41:17,240
no le importará. El artículo será enfrentarse a los valores originales.

453
00:41:17,240 --> 00:41:19,240
Vamos a tratar de desarmar la misma.

454
00:41:19,240 --> 00:41:24,460
¿Y si esto es $ array [1] = "hola";

455
00:41:24,460 --> 00:41:31,770
A pesar de que poner "hola" en la matriz, nunca tema se tiene en ese valor.

456
00:41:31,770 --> 00:41:37,430
Hay otra sintaxis para foreach bucles

457
00:41:37,430 --> 00:41:45,900
donde pones 2 variables separadas por una flecha.

458
00:41:45,900 --> 00:41:49,680
Esta primera variable va a ser la clave de ese valor,

459
00:41:49,680 --> 00:41:53,050
y esta segunda variable va a ser el artículo exacto mismo.

460
00:41:53,050 --> 00:42:01,610
Esto no es interesante aquí, pero si volvemos a nuestro caso original de 'a' - 1>,

461
00:42:01,610 --> 00:42:06,090
'B' -> 1,

462
00:42:06,090 --> 00:42:14,470
aquí si simplemente iterar para cada matriz como elemento, elemento que va a ser una cada vez.

463
00:42:14,470 --> 00:42:18,170
Pero si además queremos que conozcan la clave asociada a ese tema

464
00:42:18,170 --> 00:42:25,230
entonces hacemos como $ key -> $ item.

465
00:42:25,230 --> 00:42:31,980
Así que ahora podemos hacer print ($ key. ':'.

466
00:42:31,980 --> 00:42:39,380
Ahora se está iterando sobre e imprimir cada clave y su valor asociado.

467
00:42:39,380 --> 00:42:47,030
>> Una cosa adicional que podemos hacer en bucles foreach es que usted puede ver esta sintaxis.

468
00:42:47,030 --> 00:42:54,770
Ampersands antes de los nombres de variables tienden a ser como PHP hace referencias.

469
00:42:54,770 --> 00:43:00,460
Donde las referencias son muy similares a los punteros,

470
00:43:00,460 --> 00:43:04,820
usted no tiene punteros, por lo que nunca ocuparse de memoria directamente.

471
00:43:04,820 --> 00:43:12,620
Pero tenemos referencias donde 1 variable se refiere a la misma cosa como otra variable.

472
00:43:12,620 --> 00:43:21,450
Dentro de aquí que vamos a hacer $ item. Volvamos a 1, 10.

473
00:43:21,450 --> 00:43:28,800
Hagamos $ item + +; Que todavía existe en PHP. Usted todavía puede hacer + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Tengo que imprimir. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
Se imprimen 2, 11.

476
00:43:42,730 --> 00:43:49,560
Si yo acababa de hacer foreach ($ array como $ item) entonces ítem será el valor 1

477
00:43:49,560 --> 00:43:54,190
la primera vez a través del bucle. Se incrementará 1 a 2 y luego ya está.

478
00:43:54,190 --> 00:43:57,260
Así que entonces pasará a través de la segunda pasada del bucle y que el tema es de 10.

479
00:43:57,260 --> 00:44:01,570
Se incrementa el artículo a la 11, y luego que acaba de tirar.

480
00:44:01,570 --> 00:44:06,670
Luego print_r ($ array), y los vamos a ver que esto es sólo una de 10.

481
00:44:06,670 --> 00:44:09,070
Así, el incremento que hicimos fue perdido.

482
00:44:09,070 --> 00:44:13,410
Pero foreach ($ array como & $ item)

483
00:44:13,410 --> 00:44:21,910
ahora este artículo es el mismo artículo como este aquí. Es la misma cosa.

484
00:44:21,910 --> 00:44:26,820
Entonces, $ item + + es la modificación de matriz 0.

485
00:44:29,330 --> 00:44:41,850
Básicamente, usted también puede hacer $ k -> array $ item y usted puede hacer $ [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Así que otra manera de hacer eso, tenemos la libertad de modificar el punto,

487
00:44:48,650 --> 00:44:54,070
pero eso no va a modificar nuestra matriz original.

488
00:44:54,070 --> 00:44:59,720
Pero si utilizamos k, que es la llave, entonces podemos simplemente índice en nuestro array usando esa clave

489
00:44:59,720 --> 00:45:01,530
y que incrementar.

490
00:45:01,530 --> 00:45:05,410
Esto más directamente modifica nuestra matriz original.

491
00:45:05,410 --> 00:45:10,690
Usted puede incluso hacer que si por alguna razón usted quería que la capacidad de modificar -

492
00:45:10,690 --> 00:45:13,510
En realidad, esto es perfectamente razonable.

493
00:45:13,510 --> 00:45:16,020
Usted no quiere tener que escribir $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
que sólo quería escribir $ item + + pero todavía quería decir if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
luego incrementar artículo y luego imprimir nuestra matriz.

496
00:45:30,620 --> 00:45:36,290
¿Y ahora qué es lo que esperamos print_r hacer? ¿Qué valores se deben imprimir?

497
00:45:36,290 --> 00:45:43,770
[Estudiante] 2 y 10. >> [Bowden] Sólo si la clave era 'a' es lo que realmente imprimir eso.

498
00:45:51,940 --> 00:45:55,670
>> Es probable que muy rara vez, o nunca, se necesita definir funciones en PHP,

499
00:45:55,670 --> 00:46:03,370
pero es posible que vea algo similar en el que se define una función como cualquier función.

500
00:46:03,370 --> 00:46:09,900
Por lo general, usted diría ($ foo, $ bar) y luego definir que sea lo que sea.

501
00:46:09,900 --> 00:46:17,580
Pero si hago esto, entonces eso significa que todo lo que pide lo que sea,

502
00:46:17,580 --> 00:46:25,110
lo llama baz, por lo que el primer argumento pasado al baz se puede cambiar.

503
00:46:25,110 --> 00:46:38,100
Hagamos $ foo + +;

504
00:46:38,100 --> 00:46:48,020
y en el interior de aquí vamos a hacer baz ($ item);

505
00:46:48,020 --> 00:46:52,250
Ahora estamos llamando a una función.

506
00:46:52,250 --> 00:46:56,780
El argumento se toma como referencia, lo que significa que si lo modificar

507
00:46:56,780 --> 00:47:00,390
estamos modificando lo que se ha pasado pulg

508
00:47:00,390 --> 00:47:04,420
Y esta impresión se espera - a menos que metí la pata sintaxis - nos dieron 2, 11,

509
00:47:04,420 --> 00:47:06,300
por lo que se incrementa realmente.

510
00:47:06,300 --> 00:47:08,790
Notificación necesitamos referencias en 2 lugares.

511
00:47:08,790 --> 00:47:13,050
¿Qué pasa si lo hizo? ¿Qué quiere decir esto?

512
00:47:13,050 --> 00:47:15,810
[Estudiante] Se va a cambiar. Sí >>.

513
00:47:15,810 --> 00:47:18,290
El artículo es simplemente una copia del valor de la matriz.

514
00:47:18,290 --> 00:47:26,670
Así elemento cambia a 2, pero la matriz ['a'] todavía será 1.

515
00:47:26,670 --> 00:47:32,560
¿O qué si lo hago?

516
00:47:32,560 --> 00:47:39,260
Ahora elemento se envía una copia a baz.

517
00:47:39,260 --> 00:47:46,330
Así que la copia del argumento se incrementa a 2,

518
00:47:46,330 --> 00:47:49,240
pero el tema en sí mismo nunca fue incrementado a 2.

519
00:47:49,240 --> 00:47:52,880
Y el tema es lo mismo que la matriz de soporte que sea,

520
00:47:52,880 --> 00:47:55,380
de modo que nunca matriz se incrementó.

521
00:47:55,380 --> 00:47:57,960
Así que esos dos lugares que necesite.

522
00:47:57,960 --> 00:48:03,830
>> PHP es por lo general bastante inteligente sobre esto.

523
00:48:03,830 --> 00:48:06,570
Se podría pensar que quiero pasar por referencia -

524
00:48:06,570 --> 00:48:09,560
Esto era realmente una pregunta de uno de los conjuntos de procesadores.

525
00:48:09,560 --> 00:48:14,480
Era una cosa Questions.txt donde dice:

526
00:48:14,480 --> 00:48:19,280
¿Por qué querría pasar esta estructura por referencia?

527
00:48:19,280 --> 00:48:21,250
¿Cuál fue la respuesta?

528
00:48:21,250 --> 00:48:25,100
[Estudiante] Así que usted no tiene que copiar algo grande. Sí >>.

529
00:48:25,100 --> 00:48:32,920
Una estructura puede ser arbitrariamente grande, y cuando se pasa la estructura como argumento

530
00:48:32,920 --> 00:48:36,800
tiene que copiar esa estructura entera para pasarla a la función,

531
00:48:36,800 --> 00:48:40,410
mientras que si usted sólo tiene que pasar la estructura por referencia

532
00:48:40,410 --> 00:48:46,530
a continuación, sólo tiene que copiar una dirección de 4 bytes como argumento a la función.

533
00:48:48,520 --> 00:48:52,320
PHP es un poco más inteligente que eso.

534
00:48:52,320 --> 00:49:00,650
Si tengo alguna función y paso a un conjunto de 1.000 las cosas,

535
00:49:00,650 --> 00:49:03,990
¿eso significa que va a tener que copiar todos 1.000 de esas cosas

536
00:49:03,990 --> 00:49:10,450
para pasar a la función? No tiene que hacerlo inmediatamente.

537
00:49:10,450 --> 00:49:15,940
Si dentro de esta función en realidad nunca modifica foo,

538
00:49:15,940 --> 00:49:22,660
así if ($ foo === 'hola') devolverá true.;

539
00:49:22,660 --> 00:49:26,460
Tenga en cuenta que en realidad nunca modificó el interior argumento de esta función,

540
00:49:26,460 --> 00:49:30,010
lo que significa que todo lo que se pasa como nunca foo debe copiarse

541
00:49:30,010 --> 00:49:32,100
porque no se lo está modificando.

542
00:49:32,100 --> 00:49:39,240
Así que la forma PHP obras son los argumentos se pasan siempre por referencia

543
00:49:39,240 --> 00:49:42,170
hasta que realmente tratar de modificarlo.

544
00:49:42,170 --> 00:49:51,160
Ahora bien, si por ejemplo $ foo + + y pasará a hacer una copia del original foo y modificar la copia.

545
00:49:51,160 --> 00:49:53,090
Esto ahorra algún tiempo.

546
00:49:53,090 --> 00:49:58,210
Si nunca estás tocando este arsenal masivo, nunca en realidad lo modifica,

547
00:49:58,210 --> 00:50:02,360
no es necesario para hacer la copia,

548
00:50:02,360 --> 00:50:06,640
mientras que si sólo hay que poner este signo que significa que ni siquiera copiarlo

549
00:50:06,640 --> 00:50:08,640
incluso si usted lo modifica.

550
00:50:08,640 --> 00:50:10,680
Este comportamiento se llama copy-on-write.

551
00:50:10,680 --> 00:50:17,380
Lo verá en otros lugares, sobre todo si usted toma un curso del sistema operativo.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write es un patrón bastante usual en los que no es necesario hacer una copia de algo

553
00:50:23,880 --> 00:50:26,650
a menos que se haya cambiado realmente. Si.

554
00:50:26,650 --> 00:50:29,520
[Estudiante] ¿Qué pasa si usted tenía el incremento dentro de la prueba,

555
00:50:29,520 --> 00:50:33,700
tan sólo 1 elemento de 1.000 tendría que ser cambiado?

556
00:50:33,700 --> 00:50:38,770
No estoy seguro.

557
00:50:38,770 --> 00:50:51,250
Creo que sería copiar toda la cosa, pero es posible que es lo suficientemente inteligente como eso -

558
00:50:51,250 --> 00:51:00,020
En realidad, lo que estoy pensando es imaginar que tenía una serie que se parece a esto: $ matriz2 = [

559
00:51:00,020 --> 00:51:11,000
Entonces 'a' índice es una matriz de [1 2 3 4], y el índice de 'b' es una matriz de lo que sea.

560
00:51:11,000 --> 00:51:15,380
Necesito comas entre todos ellos. Imagina que no hay comas.

561
00:51:15,380 --> 00:51:21,210
Entonces 'c' es el valor 3.

562
00:51:24,210 --> 00:51:26,290
Bien.

563
00:51:26,290 --> 00:51:33,440
Ahora digamos que hacemos $ baz ($ matriz2);

564
00:51:33,440 --> 00:51:36,540
donde baz no considera la presente por referencia.

565
00:51:43,510 --> 00:51:47,370
Así que $ foo ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
Este es un ejemplo en el que se pasa como argumento matriz2

567
00:51:52,340 --> 00:51:57,010
y luego se está modificando un índice específico de la matriz incrementándolo.

568
00:51:57,010 --> 00:52:01,090
Honestamente no tengo idea de lo que PHP va a hacer.

569
00:52:01,090 --> 00:52:07,200
Se puede hacer fácilmente una copia de toda la cosa, pero si es inteligente,

570
00:52:07,200 --> 00:52:15,030
se hará una copia de estas llaves donde esta tendrá su valor distinto

571
00:52:15,030 --> 00:52:20,620
pero esto todavía puede apuntar a la misma matriz 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
y esto todavía puede apuntar a la misma matriz.

573
00:52:22,320 --> 00:52:24,170
Voy iPad ella.

574
00:52:28,900 --> 00:52:45,950
Pasamos en este array donde este chico a 3 puntos, esto apunta a guy [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
este chico apunta a [34, ...]

576
00:52:51,350 --> 00:52:58,590
Ahora que lo estamos pasando a baz, estamos modificando esto.

577
00:52:58,590 --> 00:53:03,550
Si PHP es inteligente, sólo puede hacer -

578
00:53:11,850 --> 00:53:18,230
Todavía tenía que copiar algo de memoria, pero si no hubiera estos subconjuntos anidados enormes

579
00:53:18,230 --> 00:53:21,560
no necesitamos copiar esos.

580
00:53:21,560 --> 00:53:27,530
No sé si eso es lo que hace, pero me imagino haciendo eso.

581
00:53:29,050 --> 00:53:36,690
Esto también es una ventaja muy grande de C sobre PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP hace la vida mucho más fácil para un montón de cosas,

583
00:53:40,320 --> 00:53:45,060
pero que tipo de tener la menor idea de lo bien que se llevará a cabo

584
00:53:45,060 --> 00:53:52,530
porque no tengo ni idea de por debajo de la capucha cuando se trata de hacer estas copias de las cosas,

585
00:53:52,530 --> 00:53:55,170
oh, es que va a ser una copia constante de tiempo,

586
00:53:55,170 --> 00:54:01,140
es sólo va a cambiar un puntero, es que va a ser una copia lineal ridículamente difícil?

587
00:54:01,140 --> 00:54:03,000
¿Y si no puede encontrar el espacio?

588
00:54:03,000 --> 00:54:06,760
¿Tiene entonces que ejecutar la recolección de basura para obtener espacio un poco más?

589
00:54:06,760 --> 00:54:11,210
Y la recolección de basura puede tomar arbitrariamente largo.

590
00:54:11,210 --> 00:54:13,600
En C no tiene que preocuparse por estas cosas.

591
00:54:13,600 --> 00:54:19,780
Cada línea que se escribe puede razonar más o menos sobre cómo se va a realizar.

592
00:54:26,800 --> 00:54:29,150
>> Vamos a mirar hacia atrás en estos.

593
00:54:35,400 --> 00:54:37,520
¡Qué bueno es que no tienes que lidiar con las funciones hash,

594
00:54:37,520 --> 00:54:39,010
listas enlazadas, ni nada de eso?

595
00:54:39,010 --> 00:54:41,980
Desde que trabajamos con tablas hash es tan fácil ahora, he aquí un rompecabezas divertido para trabajar.

596
00:54:41,980 --> 00:54:45,920
Abra un archivo llamado unique.php y en él escribe un programa PHP

597
00:54:45,920 --> 00:54:48,330
(También conocido como un "script").

598
00:54:48,330 --> 00:54:55,700
Tendemos a llamar a los scripts si son cosas cortas que se ejecutan en la línea de comandos.

599
00:54:55,700 --> 00:55:02,950
Básicamente, cualquier lenguaje que no compila pero vas a ejecutar el archivo ejecutable

600
00:55:02,950 --> 00:55:05,920
en la línea de comandos, puede llamar a ese script ejecutable.

601
00:55:05,920 --> 00:55:08,510
Yo podría muy bien escribir un programa en C que hace esto,

602
00:55:08,510 --> 00:55:12,300
pero yo no lo llamo un script desde la primera vez que compile y ejecute el archivo binario.

603
00:55:12,300 --> 00:55:15,480
Pero este programa PHP que vamos a llamar a un script.

604
00:55:15,480 --> 00:55:23,830
O si lo escribimos en Python o Perl o Node.js o cualquiera de esas cosas,

605
00:55:23,830 --> 00:55:26,500
nos llamamos todos los scripts porque se ejecutan en la línea de comandos

606
00:55:26,500 --> 00:55:30,040
pero no compilarlos.

607
00:55:30,860 --> 00:55:33,400
Podemos hacer esto con bastante rapidez.

608
00:55:36,960 --> 00:55:41,480
No vamos a utilizar argv. Vamos a volar a través de esto.

609
00:55:41,480 --> 00:55:45,730
Llámelo único, escribir un programa.

610
00:55:45,730 --> 00:55:49,400
Se puede suponer que la entrada contendrá una palabra por línea.

611
00:55:49,400 --> 00:55:52,020
En realidad, argv será bastante trivial de usar.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
Primero lo primero, queremos comprobar si se nos ha pasado un argumento de línea de comandos.

614
00:56:13,750 --> 00:56:20,900
Tal como era de esperar argc y argv en C, tenemos todavía los de PHP.

615
00:56:20,900 --> 00:56:33,900
Así que si ($ argc! == 2) entonces no voy a tratar de imprimir un mensaje o algo así.

616
00:56:33,900 --> 00:56:37,340
Voy a salir, el código de error de 1.

617
00:56:37,340 --> 00:56:41,340
También pude volver 1.

618
00:56:41,340 --> 00:56:53,180
Pocas veces en PHP que se encuentran en este estado donde estamos -

619
00:56:53,180 --> 00:56:57,820
Por lo general, usted está en una función llamada por una función llamada por una función llamada por una función.

620
00:56:57,820 --> 00:57:02,070
Y si algo sale mal y lo que desea es salir todo por completo,

621
00:57:02,070 --> 00:57:05,680
salida justo termina el programa.

622
00:57:05,680 --> 00:57:08,160
Esto también existe en C.

623
00:57:08,160 --> 00:57:10,700
Si estás en una función en una función en una función en una función

624
00:57:10,700 --> 00:57:17,540
y quiere matar sólo el programa, puede llamar a la salida y saldrá solo.

625
00:57:17,540 --> 00:57:23,120
Pero en PHP es aún más raro que nos encontramos en este nivel superior.

626
00:57:23,120 --> 00:57:26,090
Por lo general, estamos dentro de algún tipo de función, por lo que llamamos salida

627
00:57:26,090 --> 00:57:29,650
para que no tenga que volver a una cosa que se da cuenta de que hay un error

628
00:57:29,650 --> 00:57:32,270
de modo que si devuelve hasta que reconoce que fue un error.

629
00:57:32,270 --> 00:57:35,270
No queremos que lidiar con eso, así que salir (1);

630
00:57:35,270 --> 00:57:38,240
retorno (1), en este caso sería equivalente.

631
00:57:38,240 --> 00:57:44,000
>> Entonces, ¿qué queremos abrir queremos fopen.

632
00:57:44,000 --> 00:57:46,760
Los argumentos que se van a ver bastante similar.

633
00:57:46,760 --> 00:57:51,600
Queremos fopen ($ argv [1], y queremos abrirlo para su lectura.

634
00:57:51,600 --> 00:57:55,720
Esto devuelve un recurso que vamos a llamar a f.

635
00:57:55,720 --> 00:58:02,180
Esto se ve muy similar a como lo hace C excepto que no tienes que decir * FILE.

636
00:58:02,180 --> 00:58:06,170
En su lugar, sólo decir $ f. Bien.

637
00:58:06,170 --> 00:58:17,190
En realidad, creo que incluso nos da una pista en cuanto a la función de PHP llamada archivo. PHP File.

638
00:58:17,190 --> 00:58:23,990
Lo que esto va a hacer es leer un archivo entero en una matriz.

639
00:58:23,990 --> 00:58:29,770
No tienes necesidad de fopen ella. Se va a hacer eso por usted.

640
00:58:37,450 --> 00:58:43,700
Así que $ lineas = archivo ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Ahora todas las líneas del archivo están en las líneas. Ahora queremos ordenar las líneas.

642
00:58:49,680 --> 00:58:52,180
¿Cómo podemos clasificar las líneas?

643
00:58:52,180 --> 00:58:54,920
Nos ordenar las líneas.

644
00:58:54,920 --> 00:58:58,080
Y ahora podemos imprimirlas o lo que sea.

645
00:58:58,080 --> 00:59:05,580
Probablemente la forma más fácil es foreach ($ lines como $ line) echo $ line;

646
00:59:05,580 --> 00:59:10,960
[Estudiante] ¿No nos incluso cruzar las líneas haciendo referencia a algo en clase?

647
00:59:10,960 --> 00:59:28,850
Aquí es donde la especie se definiría como una especie de función (& $ array).

648
00:59:28,850 --> 00:59:32,650
Cuando se llama a la función que no pase por referencia.

649
00:59:32,650 --> 00:59:36,900
Es la función que se define como tomando como referencia.

650
00:59:36,900 --> 00:59:40,900
Esto es en realidad exactamente lo que salió mal

651
00:59:40,900 --> 00:59:46,220
cuando ponemos todo a nuestros servidores cuando fuimos 5,3 a 5,4.

652
00:59:46,220 --> 00:59:53,800
Hasta 5,4, esto era perfectamente razonable.

653
00:59:53,800 --> 00:59:58,740
Una función no tiene previsto tomar como referencia, pero se puede pasar por referencia

654
00:59:58,740 --> 01:00:02,860
así que si la función se da a modificarlo, sigue siendo modificado.

655
01:00:02,860 --> 01:00:05,850
A partir de 5,4, que no debes hacer esto.

656
01:00:05,850 --> 01:00:11,740
Así que ahora la única forma de pasar por referencia es si la función explícita que hace.

657
01:00:11,740 --> 01:00:19,840
Si usted no quiere que lo modifique, entonces usted necesita para hacer copia $ = $ pass líneas y copia.

658
01:00:19,840 --> 01:00:24,820
Así que ahora las líneas se conservará copia y será cambiada.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Yo podría haber metido algo.

660
01:00:31,460 --> 01:00:33,190
Inesperado 'especie'.

661
01:00:38,320 --> 01:00:43,850
Va a ser algo que lo hace por nosotros.

662
01:00:43,850 --> 01:00:45,820
Ni siquiera allí.

663
01:00:45,820 --> 01:00:52,140
Aviso cuando usted lee el manual que el primer argumento se espera que sea una matriz

664
01:00:52,140 --> 01:00:56,490
y se toma como referencia.

665
01:00:58,160 --> 01:01:03,540
¿Por qué se quejan a mí? Porque tengo esta especie en función todavía aquí que no quiero.

666
01:01:03,540 --> 01:01:09,210
Bueno, php.unique.php. No me pasa un argumento porque no tengo un archivo.

667
01:01:09,210 --> 01:01:13,560
Es php.unique.php en test.php.

668
01:01:13,560 --> 01:01:19,080
Aquí está test.php todos impresos en un orden bien ordenados.

669
01:01:19,080 --> 01:01:24,600
Tenga en cuenta que el orden establecido es un poco raro para un archivo de código

670
01:01:24,600 --> 01:01:27,460
porque todas nuestras líneas en blanco va a ser lo primero

671
01:01:27,460 --> 01:01:30,190
entonces van a venir todos nuestros muescas de nivel 1

672
01:01:30,190 --> 01:01:33,360
luego vienen todos nuestros muescas no.

673
01:01:33,360 --> 01:01:38,620
Si. >> [Estudiante] Así que el código fuente no se pasa por referencia?

674
01:01:38,620 --> 01:01:42,240
Es que generalmente pasa por valor?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Cuando se llama a una función, nunca se determina si se pasan por referencia.

676
01:01:50,240 --> 01:01:53,960
Es la definición de la función que determina si se pasan por referencia.

677
01:01:53,960 --> 01:01:59,450
Y mirando a la definición de la función de la especie, o simplemente buscando en esto,

678
01:01:59,450 --> 01:02:02,820
toma el argumento por referencia.

679
01:02:02,820 --> 01:02:07,160
Así que, independientemente de si desea que se tome como referencia, lo hace tomar como referencia.

680
01:02:07,160 --> 01:02:10,200
Se modifica la matriz en su lugar.

681
01:02:10,200 --> 01:02:17,400
Esto no es sólo permitida. Usted no tiene permiso para hacerlo. >> [Estudiante] Oh, está bien.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Esto, más o menos se va a tomar como referencia las líneas y modificarlo.

683
01:02:22,410 --> 01:02:26,850
Y de nuevo, si usted no quiere que haga eso, usted puede hacer una copia de género.

684
01:02:26,850 --> 01:02:35,850
Incluso en este caso, la copia no es realmente una copia de las líneas.

685
01:02:35,850 --> 01:02:40,620
Es sólo apunta a lo mismo hasta que primero es modificado,

686
01:02:40,620 --> 01:02:44,430
donde los primeros van a modificar en la función de clasificación,

687
01:02:44,430 --> 01:02:50,940
donde, porque es copy-on-write, ahora una copia del ejemplar que va a realizar.

688
01:02:57,500 --> 01:03:04,250
También puede hacer esto. Ese es el lugar que usted puede ver y comercial.

689
01:03:04,250 --> 01:03:07,190
Lo ves en los bucles foreach, lo ves en la declaración de funciones,

690
01:03:07,190 --> 01:03:10,040
y lo ves cuando la asignación a variables.

691
01:03:10,040 --> 01:03:12,350
Y nosotros no hemos hecho nada al hacer esto

692
01:03:12,350 --> 01:03:15,600
porque la copia y las líneas son literalmente la misma cosa.

693
01:03:15,600 --> 01:03:19,940
Usted puede utilizar las líneas y copiar de manera intercambiable.

694
01:03:19,940 --> 01:03:25,430
Usted puede hacer unset ($ copia), y que no las líneas no definidas,

695
01:03:25,430 --> 01:03:29,120
que acaba de perder su referencia a lo mismo.

696
01:03:29,120 --> 01:03:33,440
Así que a partir de este punto, ahora líneas es la única manera de acceder a líneas.

697
01:03:36,450 --> 01:03:38,770
>> ¿Preguntas?

698
01:03:41,000 --> 01:03:42,460
Si.

699
01:03:42,460 --> 01:03:45,880
[Estudiante] completamente fuera de tema, pero usted no tiene que cerrar PHP con la opción - >> No lo sabes.

700
01:03:45,880 --> 01:03:47,730
Bien.

701
01:03:47,730 --> 01:03:53,790
[Bowden] Yo iría tan lejos como para decir que es una mala práctica para cerrarlas.

702
01:03:53,790 --> 01:03:57,580
Eso es probablemente una exageración, sobre todo en un script,

703
01:03:57,580 --> 01:04:03,740
pero vamos a ver qué pasa si hago esto.

704
01:04:03,740 --> 01:04:08,890
Eso no hizo nada. ¿Qué pasa si yo quería - [Suspira]

705
01:04:13,870 --> 01:04:16,960
Tengo que pasar un argumento.

706
01:04:19,000 --> 01:04:22,050
Dispara. Llamé mal.

707
01:04:24,340 --> 01:04:28,310
Así php.unique.php con un argumento.

708
01:04:28,310 --> 01:04:30,980
Ahora ya no tienes necesidad de esto.

709
01:04:34,520 --> 01:04:37,740
Voy a pasar un argumento válido.

710
01:04:37,740 --> 01:04:42,050
Este impreso lo que es la impresión.

711
01:04:45,260 --> 01:04:50,080
Estoy imprimiendo copia y la copia no existe. Así líneas.

712
01:04:53,650 --> 01:04:58,270
Se imprimirá todo, y después se da cuenta toda esta basura aquí abajo,

713
01:04:58,270 --> 01:05:06,690
porque en nada PHP que se encuentra fuera de las etiquetas PHP

714
01:05:06,690 --> 01:05:09,520
sólo va a imprimir literalmente.

715
01:05:09,520 --> 01:05:18,050
Es por eso que HTML, es tan bonito que puedo hacer div bla, bla, bla, clase o lo que sea,

716
01:05:18,050 --> 01:05:25,140
bla, bla, bla, y luego hacer algo de código PHP y entonces hacer div fin.

717
01:05:25,140 --> 01:05:36,460
Y ahora esto me da la impresión de mi div bonito encima de la tapa, todo lo que PHP impreso, div en la parte inferior.

718
01:05:36,460 --> 01:05:43,510
Desastroso cuando sucede algo como esto, que es bastante común,

719
01:05:43,510 --> 01:05:47,930
sólo una nueva línea parásita en la parte inferior de archivo.

720
01:05:47,930 --> 01:05:50,940
Usted no pensaría que sería tan grande de un acuerdo

721
01:05:50,940 --> 01:05:58,660
hasta que se tiene en cuenta el hecho de que con los navegadores -

722
01:05:58,660 --> 01:06:03,880
>> Cómo redirigir el trabajo o básicamente cualquier trabajo encabezados,

723
01:06:03,880 --> 01:06:07,980
al realizar la conexión con un sitio web y lo envía de vuelta todas estas cabeceras y cosas

724
01:06:07,980 --> 01:06:12,020
como respuesta o la respuesta de redirección 200 o lo que sea,

725
01:06:12,020 --> 01:06:18,230
encabezados sólo son válidos hasta el primer byte de datos se envían.

726
01:06:18,230 --> 01:06:23,140
Puede redirigir miles de veces, pero tan pronto como el primer byte de datos se envía

727
01:06:23,140 --> 01:06:26,120
que no se supone para redirigir de nuevo.

728
01:06:26,120 --> 01:06:31,860
>> Si tiene una perdida de nueva línea en la parte inferior de un archivo

729
01:06:31,860 --> 01:06:37,260
y digamos que utilice esta función y entonces usted quiere -

730
01:06:41,580 --> 01:06:52,870
Digamos que es otro archivo que es index.php y require_once algo -

731
01:06:52,870 --> 01:06:56,920
No puedo pensar en un buen ejemplo de ello.

732
01:06:56,920 --> 01:07:04,740
El problema ocurre cuando esta línea en la parte inferior se hizo eco.

733
01:07:04,740 --> 01:07:08,660
Usted no quiere que nada se ha hecho eco todavía.

734
01:07:10,820 --> 01:07:15,700
A pesar de que no tenía la intención de conseguir cualquier cosa se hizo eco, algo que sí conseguimos eco

735
01:07:15,700 --> 01:07:17,990
y lo que ahora se supone que no debes enviar las cabeceras de ninguna otra

736
01:07:17,990 --> 01:07:20,030
y usted va a recibir quejas.

737
01:07:22,170 --> 01:07:24,420
Uno no necesita esas etiquetas de cierre.

738
01:07:24,420 --> 01:07:27,420
Si tienes pensado hacer algo con HTML -

739
01:07:27,420 --> 01:07:30,490
y es perfectamente razonable para hacerlo aquí div cualquier

740
01:07:30,490 --> 01:07:39,450
y en este punto se puede o no se pueden incluir.

741
01:07:39,450 --> 01:07:41,590
En realidad no importa.

742
01:07:41,590 --> 01:07:45,450
Pero en scripts PHP es raro para cerrarla.

743
01:07:45,450 --> 01:07:50,400
Cuando todo es PHP, absolutamente todo,

744
01:07:50,400 --> 01:07:55,460
usted realmente no necesita para cerrarlo / no debes cerrarlo.

745
01:08:02,030 --> 01:08:05,720
>> Tratar con cadenas es mucho más agradable que en C.

746
01:08:05,720 --> 01:08:09,470
En PHP se puede especificar una cadena con comillas simples o dobles.

747
01:08:09,470 --> 01:08:12,820
Con comillas simples no se puede utilizar "escape" secuencias.

748
01:08:12,820 --> 01:08:17,640
Constantemente escapar, blah, blah, blah.

749
01:08:19,920 --> 01:08:24,010
Así que printf es muy raro en PHP.

750
01:08:24,010 --> 01:08:32,290
Supongo que me gustaría utilizar printf si quería hacer una especie de cosa - en el conjunto de procesadores que utiliza sprintf 5 o lo que sea.

751
01:08:32,290 --> 01:08:36,060
Pero que quieres hacer 001.jpg 002.jpg y.

752
01:08:36,060 --> 01:08:40,300
Así que para ese tipo de cosas en el que realmente desea formatear el texto me gustaría utilizar printf.

753
01:08:40,300 --> 01:08:44,689
Pero por lo demás me acaba de utilizar la concatenación de cadenas.

754
01:08:44,689 --> 01:08:47,000
Realmente nunca usar printf.

755
01:08:49,229 --> 01:09:00,170
Sólo estamos diferenciando los detalles entre comillas simples y comillas dobles.

756
01:09:00,170 --> 01:09:07,490
La mayor diferencia es que las comillas simples, se imprimirá literalmente.

757
01:09:07,490 --> 01:09:15,390
No hay ningún tipo de datos char en PHP, a diferencia de C, así que esto es equivalente a esto.

758
01:09:15,390 --> 01:09:17,970
Los dos son cadenas.

759
01:09:17,970 --> 01:09:29,180
Y lo bueno acerca de las cadenas de comillas simples se podría decir 'hola mundo! " bla, bla, bla,

760
01:09:29,180 --> 01:09:33,340
$ $ Wooo.

761
01:09:33,340 --> 01:09:38,260
¿Qué sucede cuando se trata de imprimir lo va a imprimir literalmente.

762
01:09:38,260 --> 01:09:40,680
Vamos a deshacernos de todas nuestras cosas.

763
01:09:40,680 --> 01:09:44,700
Así que echo $ cadena1;

764
01:09:48,569 --> 01:09:56,570
Es, literalmente, impreso todas esas cosas: signos de dólar,

765
01:09:56,570 --> 01:09:58,770
backslash n, que uno pensaría que sería saltos de línea -

766
01:09:58,770 --> 01:10:01,500
todas esas cosas que se imprime la letra.

767
01:10:01,500 --> 01:10:05,650
Lo único que se necesita para escapar comillas simples son

768
01:10:05,650 --> 01:10:09,470
porque de lo contrario podría pensar que va a cerrar las comillas simples.

769
01:10:09,470 --> 01:10:15,050
Las comillas dobles, completamente diferentes.

770
01:10:20,300 --> 01:10:25,870
Ya vemos el resaltado de sintaxis se nos cluing a lo que va a ir muy mal.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo porque esto se interpreta como una variable llamada wooo.

772
01:10:36,190 --> 01:10:42,400
Las comillas dobles permiten insertar variables en -

773
01:10:42,400 --> 01:10:52,730
Digamos que $ name = "Rob";

774
01:10:52,730 --> 01:10:58,020
Así que echo "Hola, mi nombre es $ nombre!";

775
01:10:58,020 --> 01:11:09,260
Se reconoce esto como una variable.

776
01:11:09,260 --> 01:11:21,210
Cuando ejecuto esto - y voy a insertar un salto de línea - Hola, mi nombre es Rob! y hola mundo!

777
01:11:21,210 --> 01:11:24,910
Esto se debe a que nunca le quité la impresión de wooo arriba.

778
01:11:24,910 --> 01:11:30,020
Hay un paso más que puede hacer.

779
01:11:30,020 --> 01:11:39,250
$ Array = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
¿Qué pasa si quiero imprimir el primer índice de la matriz?

781
01:11:43,270 --> 01:11:45,150
Usted hace $ array [0].

782
01:11:45,150 --> 01:11:49,280
El resaltado de sintaxis es una pista. ¿Qué es esto va a hacer?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
Hola, mi nombre es 1! que no es lo que yo quería.

785
01:11:59,860 --> 01:12:05,050
El resaltado de sintaxis me mintió.

786
01:12:05,050 --> 01:12:13,020
Vamos a probar 'a' -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
Así es como yo tendría que escribir.

788
01:12:26,350 --> 01:12:32,160
Cita inesperada único (T_ENCAPSED blah, blah, blah, blah, blah).

789
01:12:32,160 --> 01:12:41,780
La idea es que no se reconoce esto como parte de la matriz.

790
01:12:41,780 --> 01:12:46,620
No está reconociendo esto como matriz indexada por una letra.

791
01:12:46,620 --> 01:12:49,870
¿Quieres hacer que entre llaves,

792
01:12:49,870 --> 01:12:54,730
y ahora lo que hay en esta llave de cierre serán interpolados,

793
01:12:54,730 --> 01:13:00,340
que es la palabra que usamos para mágicamente la inserción de estas variables en los lugares correctos.

794
01:13:00,340 --> 01:13:04,280
Ahora hacer esto, php.unique y Hola, mi nombre es 1! como se esperaba

795
01:13:04,280 --> 01:13:07,720
o Hola, mi nombre es Rob!

796
01:13:14,110 --> 01:13:23,130
Una cosa que es un poco agradable acerca de comillas simples es que -

797
01:13:23,130 --> 01:13:28,480
Hay algún costo para la interpolación.

798
01:13:30,520 --> 01:13:35,100
Si utiliza comillas, el intérprete tiene que ir a través de esta cadena,

799
01:13:35,100 --> 01:13:41,500
asegurando que, "Oh, aquí está una variable. Ahora tengo que ir a buscar esa variable e insertarla aquí."

800
01:13:41,500 --> 01:13:48,930
Incluso si usted no utiliza ninguna variable,

801
01:13:48,930 --> 01:13:52,220
nada dentro de estas comillas necesita ser interpolados,

802
01:13:52,220 --> 01:13:56,800
pero todavía será más lento porque tiene que ir a través de las comillas dobles

803
01:13:56,800 --> 01:14:00,130
en busca de cosas que necesitan ser interpolados.

804
01:14:00,130 --> 01:14:05,360
Así citas individuales puede ser un poco más rápido si nada necesita ser interpolados,

805
01:14:05,360 --> 01:14:15,650
y tiendo a incluso utilizar comillas simples para: 'Hola, mi nombre es'. $ Array ['a'] de todos modos.

806
01:14:15,650 --> 01:14:20,430
Eso va a ser equivalente a lo que teníamos antes.

807
01:14:24,840 --> 01:14:28,440
Pero es una cuestión de preferencia.

808
01:14:28,440 --> 01:14:34,750
Si usted está usando PHP, es probable que no les importa la diferencia de velocidad.

809
01:14:34,750 --> 01:14:39,480
No es suficiente para razonar, para empezar.

810
01:14:39,480 --> 01:14:43,030
>> Una pregunta final?

811
01:14:47,430 --> 01:14:51,710
>> En realidad, ni siquiera pasar por todo esto, pero esto era aburrido.

812
01:14:51,710 --> 01:14:59,080
La última cosa que una especie de agradable en PHP es cuando usted está tratando con HTML,

813
01:14:59,080 --> 01:15:06,450
lo vas a usar un poco, así que la sintaxis buen atajo para imprimir una variable.

814
01:15:32,400 --> 01:15:36,730
Sin poner PHP aquí, esto se llama etiquetas cortas.

815
01:15:36,730 --> 01:15:44,330
Oficialmente a partir de PHP 5.4, esta no se utiliza.

816
01:15:44,330 --> 01:15:48,640
Se recomienda poner php.

817
01:15:48,640 --> 01:15:55,770
Esto es aun soportada, etiqueta cortas con el <? = Son todavía perfectamente bien.

818
01:15:55,770 --> 01:16:02,480
Es apoyada por defecto, así que usted puede utilizar éstos como desee, y son bastante convenientes.

819
01:16:02,480 --> 01:16:05,700
>> ¿Alguna pregunta?

820
01:16:07,780 --> 01:16:09,270
Está bien.

821
01:16:10,840 --> 01:16:13,800
>> Mantén la clase, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Risas]

823
01:16:18,620 --> 01:16:22,660
Bye. [Risas]

824
01:16:24,350 --> 01:16:28,470
[Aplausos] [se ríe]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]