1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Sección 8 - máis 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 é CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> Estas notas de sección semanas van ser moi curto,

5
00:00:14,160 --> 00:00:19,070
entón eu só vou continuar a falar, vostedes van continuar a facer preguntas,

6
00:00:19,070 --> 00:00:22,720
e imos tratar encher o tempo, tanto como sexa posible.

7
00:00:22,720 --> 00:00:31,950
Moita xente pensa que este pset non é necesariamente difícil, pero é moi longo.

8
00:00:31,950 --> 00:00:37,070
A especificación pset si leva unha hora para ler.

9
00:00:40,530 --> 00:00:45,730
Nós dámoslle unha morea de SQL que podería posiblemente necesidade de usar.

10
00:00:45,730 --> 00:00:50,520
Nos leva-lo a través de unha chea de que, por iso non debe ser moi malo.

11
00:00:50,520 --> 00:00:54,560
Alguén xa comezou ou rematou?

12
00:00:55,380 --> 00:00:59,710
É o pset pasado. Oh, meu Deus.

13
00:00:59,710 --> 00:01:05,400
Normalmente hai un JavaScript un despois, pero as cousas cambian calendario

14
00:01:05,400 --> 00:01:09,560
fai todo unha semana máis curta, e non temos un pset JavaScript.

15
00:01:09,560 --> 00:01:12,310
Eu non sei como iso afecta o JavaScript está indo a aparecer no exame

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

17
00:01:15,510 --> 00:01:22,260
Imaxino que será algo así como que precisa saber cousas de alto nivel sobre JavaScript

18
00:01:22,260 --> 00:01:26,460
pero dubido que acabara de darlle directamente o código JavaScript

19
00:01:26,460 --> 00:01:28,720
xa que non tiña un pset nel.

20
00:01:28,720 --> 00:01:33,000
Pero iso vai ser o material para a súa análise proba a próxima semana.

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

22
00:01:36,320 --> 00:01:43,870
Unha gran cantidade deste material é un pouco mal formulada, pero imos discutir por que.

23
00:01:43,870 --> 00:01:50,220
Ao contrario de C, PHP é unha "dinamicamente tipada" lingua. O que isto significa, lle pregunta?

24
00:01:50,220 --> 00:01:53,830
Ben, diga adeus a todos aqueles float, char, int e outras palabras clave que necesita para utilizar

25
00:01:53,830 --> 00:01:56,190
ao declarar variables e funcións en C.

26
00:01:56,190 --> 00:02:00,420
No PHP, tipo dunha variable é determinado polo valor que está detén.

27
00:02:00,420 --> 00:02:04,990
Así, antes de escribir este código nun arquivo chamado dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP é dinámicamente ingresaran. Iso é verdade.

29
00:02:12,670 --> 00:02:17,590
Eu desacordo co feito de que iso significa que estamos dicindo adeus a char, int, float,

30
00:02:17,590 --> 00:02:20,620
e outras palabras clave.

31
00:02:20,620 --> 00:02:25,510
A diferenza exacta entre tipagem dinámica e alternativa,

32
00:02:25,510 --> 00:02:32,010
que é ingresaran estaticamente, que tipagem dinámica, toda a súa comprobación de tipo e material

33
00:02:32,010 --> 00:02:37,350
acontece en tempo de execución, mentres que tipagem estática acontece en tempo de compilación.

34
00:02:37,350 --> 00:02:43,030
A palabra estática en xeral parece significar cousas tempo de compilación.

35
00:02:43,030 --> 00:02:48,170
Coido que existen outros usos para el, pero en C cando declara unha variable estática,

36
00:02:48,170 --> 00:02:52,650
seu almacenamento é alocado en tempo de compilación.

37
00:02:52,650 --> 00:02:59,260
Aquí, tipagem dinámica significa só que -

38
00:02:59,260 --> 00:03:04,350
C, se tentar engadir unha cadea e un enteiro, cando compilar,

39
00:03:04,350 --> 00:03:11,000
vai reclamar, porque vai dicir que non pode engadir un int e un punteiro.

40
00:03:11,000 --> 00:03:14,710
Non é só unha operación válida.

41
00:03:14,710 --> 00:03:21,170
Esa é outra cousa que nós imos chegar a un segundo.

42
00:03:21,170 --> 00:03:24,860
Pero este tipo de verificación, o feito de que se queixa en tempo de compilación,

43
00:03:24,860 --> 00:03:29,220
é a comprobación de tipo estático.

44
00:03:29,220 --> 00:03:35,220
Hai linguas que non precisa dicir float, char, int, e todas esas cousas,

45
00:03:35,220 --> 00:03:40,940
pero a linguaxe pode dicir a partir do contexto da cousa que tipo que se quere que sexa,

46
00:03:40,940 --> 00:03:43,980
pero aínda tipagem estática.

47
00:03:43,980 --> 00:03:49,000
Entón, se tomar 51, OCaml, nunca precisa utilizar calquera destes tipos,

48
00:03:49,000 --> 00:03:58,700
pero aínda vai a tempo de compilación dicir que non pode facer iso porque está mesturando un int e unha corda.

49
00:03:58,700 --> 00:04:05,650
Dinámicamente ingresaran só significa que nalgún momento durante o tempo de execución que está indo para obter unha reclamación.

50
00:04:05,650 --> 00:04:13,430
Se tamén usado Java antes de, en xeral, case todas as linguas do tipo C

51
00:04:13,430 --> 00:04:20,070
vai ser ingresaran estaticamente, para C, C + +, Java, todos estes son xeralmente ingresaran estaticamente.

52
00:04:20,070 --> 00:04:22,910
En Java, cando compilar algo e está dicindo

53
00:04:22,910 --> 00:04:26,670
cadea s equivale a algo novo que non é unha cadea,

54
00:04:26,670 --> 00:04:28,950
que vai reclamar porque eses tipos simplemente non combinan.

55
00:04:28,950 --> 00:04:31,180
Que vai reclamar en tempo de compilación.

56
00:04:31,180 --> 00:04:36,750
Pero el tamén ten un tempo dinámica cousas como se tentar publicar algunha cousa

57
00:04:36,750 --> 00:04:40,500
para un tipo que é máis específico que o seu tipo de corrente,

58
00:04:40,500 --> 00:04:45,610
non hai nada que pode facer en tempo de compilación para comprobar que o elenco está indo a ter éxito.

59
00:04:45,610 --> 00:04:51,130
Java tamén ten algún tipo dinámico comprobar que, logo que se chega a esta liña de código

60
00:04:51,130 --> 00:04:54,130
cando é, en realidade, a execución, que vai facer o reparto,

61
00:04:54,130 --> 00:04:56,260
comprobar se aquel elenco era válido, en primeiro lugar,

62
00:04:56,260 --> 00:04:59,890
e se non está, entón vai reclamar que ten un tipo incorrecto.

63
00:04:59,890 --> 00:05:03,200
Tipo dinámico verificación.

64
00:05:03,200 --> 00:05:07,010
Escriba isto nun arquivo chamado dynamic.php.

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

66
00:05:14,580 --> 00:05:17,190
Vou descomprimir que o formato.

67
00:05:18,750 --> 00:05:21,880
Temos unha variable, estableza o enteiro 7,

68
00:05:21,880 --> 00:05:27,930
entón imos imprimir lo e s% -

69
00:05:27,930 --> 00:05:32,830
Ah, estamos imprimindo tipo del, de xeito gettype vai voltar tipo de variable.

70
00:05:32,830 --> 00:05:35,720
Estamos só a impresión do tipo de unha e outra vez.

71
00:05:35,720 --> 00:05:39,440
Nós só php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Imos ver o que cambia de completo cadea para Boolean coma nós pasamos.

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

74
00:05:54,590 --> 00:06:00,500
Hai char * e Boolean só tende a ser int ou char ou algo así.

75
00:06:00,500 --> 00:06:05,690
No PHP estes tipos non existen, e iso é unha das grandes vantaxes do PHP sobre C -

76
00:06:05,690 --> 00:06:13,290
secuencia de operacións que son infinitamente máis fácil do que en PHP C. Eles só traballar.

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

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

79
00:06:21,260 --> 00:06:26,710
Isto di o intérprete PHP, chamado php, para executar o código PHP en dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Se ten calquera erro no ficheiro, o intérprete pode dicir-lle!

81
00:06:30,250 --> 00:06:39,110
O intérprete, esta é outra gran diferenza entre PHP e C.

82
00:06:39,110 --> 00:06:48,200
C ten que compilar algo logo executar o arquivo compilado.

83
00:06:48,200 --> 00:06:50,490
No PHP nunca compilar nada.

84
00:06:50,490 --> 00:06:57,200
Así, o intérprete de PHP é, basicamente, só lendo esta liña por liña.

85
00:06:57,200 --> 00:07:02,900
Chega var = 7, a continuación, ela atinxe printf entón chega var entón chega printf e así por diante.

86
00:07:02,900 --> 00:07:10,910
Hai un pouco de compilar que fai, e almacena en caché os resultados

87
00:07:10,910 --> 00:07:15,510
por iso, se executar o script máis tarde pode facer algúns,

88
00:07:15,510 --> 00:07:19,280
pero basicamente é unha liña por liña tipo de cousas.

89
00:07:19,280 --> 00:07:25,280
Isto significa que unha morea de optimizacións que nós comezamos en C,

90
00:07:25,280 --> 00:07:31,920
como a compilación, é só xeralmente o compilador pode facer unha chea de trucos para ti.

91
00:07:31,920 --> 00:07:36,110
Pode aproveitar as variables utilizadas, pode facer todos eses tipos de cousas,

92
00:07:36,110 --> 00:07:38,660
pode facer recursão de cola.

93
00:07:38,660 --> 00:07:42,550
No PHP non está indo para obter esa vantaxe

94
00:07:42,550 --> 00:07:45,690
porque só vai comezar a executar liña por liña por liña,

95
00:07:45,690 --> 00:07:49,950
e realmente non recoñecer esas cousas tan facilmente

96
00:07:49,950 --> 00:07:54,440
xa que non é un paso de compilación de gran sobre a cousa e, a continuación, a execución;

97
00:07:54,440 --> 00:07:56,860
é só liña por liña.

98
00:08:00,730 --> 00:08:02,750
Entón ese é o intérprete.

99
00:08:02,750 --> 00:08:06,840
>> Voltar á nosa tipagem dinámica: moi legal, ne?

100
00:08:06,840 --> 00:08:08,640
Vostede definitivamente non podería facelo en C!

101
00:08:08,640 --> 00:08:11,860
Agora, vexa se pode descubrir o tipo de cada un dos seguintes valores.

102
00:08:11,860 --> 00:08:14,760
Vexa este a referencia.

103
00:08:14,760 --> 00:08:19,420
Entón, 3,50. Que tipo pensas que vai ser?

104
00:08:24,480 --> 00:08:26,370
Aquí están os tipos que temos.

105
00:08:26,370 --> 00:08:30,430
Temos bools, enteiros, puntos flotantes, cadeas, arrays, obxectos,

106
00:08:30,430 --> 00:08:38,370
e recursos, que é unha especie de vaga.

107
00:08:38,370 --> 00:08:41,010
Eu creo que hai, en realidade, un exemplo aquí.

108
00:08:41,010 --> 00:08:43,740
Entón hai NULL. NULL é un tipo especial.

109
00:08:43,740 --> 00:08:47,140
Ao contrario de C onde NULL é só un punteiro co enderezo 0,

110
00:08:47,140 --> 00:08:54,930
en PHP, NULL é o seu propio tipo, onde o único válido de que tipo é NULL.

111
00:08:57,560 --> 00:09:00,670
Isto é moito máis útil para comprobación de erros.

112
00:09:00,670 --> 00:09:04,310
C, onde tivemos esta cuestión onde se voltar NULL,

113
00:09:04,310 --> 00:09:08,660
iso significa que está retornando un punteiro NULL ou usar NULL para indicar erro

114
00:09:08,660 --> 00:09:12,380
ou toda esa confusión que tivo nun punto.

115
00:09:12,380 --> 00:09:18,440
Aquí, retornando NULL xeralmente significa erro.

116
00:09:20,860 --> 00:09:27,300
Unha morea de cousas tamén retornar false para erro.

117
00:09:27,300 --> 00:09:33,140
Pero o punto é o tipo NULL, o único do tipo NULL é NULL.

118
00:09:33,140 --> 00:09:40,090
Entón callback é como pode definir algunhas funcións anónimas.

119
00:09:40,090 --> 00:09:46,420
Non ten que dar a función dun nome, pero non terá que tratar con isto aquí.

120
00:09:46,420 --> 00:09:53,940
Mirando para os tipos que eles esperan que a xente sabe,

121
00:09:53,940 --> 00:09:59,000
¿Que pensas do tipo de 3,50 é? >> [Alumno] Float.

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

123
00:10:00,370 --> 00:10:06,290
Entón aquí, o que pensas do tipo de que é iso? >> [Alumno] Array.

124
00:10:06,290 --> 00:10:09,890
Si A primeira foi a boia, a segunda é unha matriz.

125
00:10:09,890 --> 00:10:14,500
Teña en conta que esta matriz non é como unha matriz C

126
00:10:14,500 --> 00:10:19,610
onde ten índice 0 ten algún valor, índice 1 ten algún valor.

127
00:10:19,610 --> 00:10:26,320
Aquí, os índices son A, B, e C, e os valores son 1, 2, e 3.

128
00:10:26,320 --> 00:10:33,980
No PHP, non hai diferenza entre unha matriz asociativa e só unha matriz común

129
00:10:33,980 --> 00:10:36,740
como sería de pensar niso en C.

130
00:10:36,740 --> 00:10:43,040
Non é só iso, e baixo o capó dunha matriz regular é só unha matriz asociativa

131
00:10:43,040 --> 00:10:50,000
onde 0 mapas para algún valor da mesma maneira unha mapas para algún valor.

132
00:10:50,000 --> 00:11:00,410
Por este motivo, o PHP pode ser moi malo para realmente rápidos / code aferição cousas

133
00:11:00,410 --> 00:11:07,930
xa que en C, cando está usando unha matriz que vostede sabe que o acceso a un membro é tempo constante.

134
00:11:07,930 --> 00:11:11,860
No PHP accedendo un membro é quen sabe canto tempo?

135
00:11:11,860 --> 00:11:18,970
Probablemente é constante se hashes correctamente.

136
00:11:18,970 --> 00:11:21,620
Quen sabe o que está realmente facendo debaixo do capo?

137
00:11:21,620 --> 00:11:25,600
Vostede realmente precisa de ollar para a implementación para ver como vai tratar con isto.

138
00:11:25,600 --> 00:11:28,550
Entón fopen.

139
00:11:28,550 --> 00:11:36,420
Eu creo que aquí imos só PHP fopen manual para ollar para o tipo de retorno.

140
00:11:36,420 --> 00:11:41,260
Vemos aquí que pode mirar para arriba practicamente calquera función na guía de PHP

141
00:11:41,260 --> 00:11:47,540
e este é o tipo de home á páxina de PHP.

142
00:11:47,540 --> 00:11:51,060
O tipo de retorno vai ser de recursos.

143
00:11:51,060 --> 00:11:56,050
É por iso que eu olhei para arriba, porque realmente non definir recursos.

144
00:11:56,050 --> 00:12:04,110
A idea de recurso, en C ten un tipo de ficheiro * ou o que quere;

145
00:12:04,110 --> 00:12:07,200
en PHP recurso é o seu arquivo *.

146
00:12:07,200 --> 00:12:10,360
É o que vai estar lendo, é o que vai ser escribindo.

147
00:12:10,360 --> 00:12:20,710
É xeralmente externo, por iso é un recurso que pode tirar cousas e tirar cousas para.

148
00:12:20,710 --> 00:12:26,520
E, finalmente, cal é o tipo de NULL? >> [Alumno] NULL.

149
00:12:26,520 --> 00:12:30,650
Si Entón a única cousa que é NULL se NULL.

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

151
00:12:35,490 --> 00:12:41,170
>> Unha característica do sistema PHP tipo (para mellor ou para peor) é a súa capacidade de facer malabarismos tipos.

152
00:12:41,170 --> 00:12:44,390
Cando escribir unha liña de código PHP que combina valores de diferentes tipos,

153
00:12:44,390 --> 00:12:46,670
PHP vai facer as cousas corda.

154
00:12:46,670 --> 00:12:48,920
Proba cada unha das seguintes liñas de código PHP. O que está impreso?

155
00:12:48,920 --> 00:12:51,000
É o que esperaba? Por que ou por que non?

156
00:12:51,000 --> 00:12:58,600
Este feito sobre o PHP é o que fai o que chamamos feblemente tipada.

157
00:12:58,600 --> 00:13:04,610
Feblemente ingresaran e rixidez,

158
00:13:04,610 --> 00:13:06,840
hai usos diferentes para estes termos,

159
00:13:06,840 --> 00:13:12,020
pero a maioría das persoas usan feblemente ingresaran e rixidez para dicir este tipo de cousas

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

161
00:13:15,920 --> 00:13:18,290
C que non ía funcionar.

162
00:13:18,290 --> 00:13:22,490
Podes imaxinar iso non funciona.

163
00:13:22,490 --> 00:13:29,200
Unha morea de xente mesturar tipagem dinámica e tipagem feble e tipagem estática e tipagem forte.

164
00:13:29,200 --> 00:13:34,050
Python é outro exemplo dunha linguaxe que é dinámicamente ingresaran.

165
00:13:34,050 --> 00:13:41,770
Pode xogar en torno a tipos de variables e que vai determinar en tempo de execución

166
00:13:41,770 --> 00:13:44,680
os controis de erro.

167
00:13:44,680 --> 00:13:50,740
En Python vai executar iso e vai ver ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
e iso vai fallar porque el di que non pode engadir unha cadea e un enteiro.

169
00:13:55,920 --> 00:14:00,860
No PHP, que é tan tipagem dinámica, iso non vai fallar.

170
00:14:00,860 --> 00:14:04,220
Tipagem feble ten que ver co feito de que fai cousas co tipo

171
00:14:04,220 --> 00:14:07,800
que realmente non ten sentido necesariamente.

172
00:14:07,800 --> 00:14:17,420
Entón ("1" + 2), podo imaxinar que ser o de 12 cordas, podo imaxinar que sexa a secuencia de tres,

173
00:14:17,420 --> 00:14:20,710
Podo imaxinar que sexa o 3 enteiro.

174
00:14:20,710 --> 00:14:24,530
Non é necesariamente ben definido, e probablemente imos ver aquí

175
00:14:24,530 --> 00:14:29,140
que cando imprimir ("1" + 2), que probablemente vai acabar por ser diferente

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

177
00:14:32,320 --> 00:14:39,700
E iso tende a ser, na miña opinión, a peor.

178
00:14:39,700 --> 00:14:44,240
Aquí podemos probar estes.

179
00:14:44,240 --> 00:14:48,740
Outro truco pouco sobre PHP é que non precisa realmente gravar o ficheiro.

180
00:14:48,740 --> 00:14:52,790
El ten de executar este modo de mando.

181
00:14:52,790 --> 00:14:57,710
Entón php-r, entón podemos xogar no mando aquí:

182
00:14:57,710 --> 00:15:06,610
"Imprimir ('1 '+ 2);" e eu vou publicar unha nova liña.

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 e é o 3 enteiro.

185
00:15:35,330 --> 00:15:38,420
Entón, agora imos tratar o contrario:

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

187
00:15:45,560 --> 00:15:50,490
Temos 3, e iso tamén vai ser enteiro 3? Sinceramente, non teño idea.

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

189
00:15:54,030 --> 00:15:59,550
Nunca hai ningunha oportunidade de el ser o 12 cordas ou algo así

190
00:15:59,550 --> 00:16:08,080
porque o PHP, ao contrario de JavaScript e Java tamén,

191
00:16:08,080 --> 00:16:11,670
ten un operador separado para concatenação.

192
00:16:11,670 --> 00:16:14,930
Concatenação en PHP é punto.

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

194
00:16:25,790 --> 00:16:32,420
Iso tende a levar a unha confusión onde as persoas tentan facer algo como str + =

195
00:16:32,420 --> 00:16:37,840
algunha outra cousa que eles queren engadir ao final da súa corda, e que vai fallar.

196
00:16:37,840 --> 00:16:40,770
Cómpre facer str. =

197
00:16:42,000 --> 00:16:46,240
Entón non se esqueza de concatenação en PHP é un punto.

198
00:16:46,240 --> 00:16:52,100
Outras cousas para intentar: Imprimir ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Eu xa lle dixen que non hai esperanza de que isto resulte en CS50

200
00:17:03,610 --> 00:17:06,119
sempre que non é a concatenação +.

201
00:17:06,119 --> 00:17:08,440
¿Que pensas que iso vai acabar sendo?

202
00:17:10,359 --> 00:17:13,460
Eu sinceramente non teño absolutamente ningunha idea.

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

204
00:17:16,460 --> 00:17:21,490
El ve a corda, e eu aposto que se colocarmos 123CS -

205
00:17:21,490 --> 00:17:29,640
El ve a primeira corda, el tenta ler un número enteiro de que ou un número a partir del.

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

207
00:17:31,710 --> 00:17:35,190
"Isto non ten sentido como un número enteiro, entón eu só vou pensar en 123."

208
00:17:35,190 --> 00:17:38,580
Entón 123 + 50 vai ser 173.

209
00:17:38,580 --> 00:17:40,740
E aquí comeza a ler isto como un número enteiro.

210
00:17:40,740 --> 00:17:45,690
Non ve nada, por iso só trata como 0. Entón 0 + 50 vai ser 50.

211
00:17:45,690 --> 00:17:51,600
Isto que estou supondo que vai facer algo semellante.

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

213
00:17:54,310 --> 00:17:57,580
Si, porque vai tomar a primeira -

214
00:18:12,880 --> 00:18:15,730
Entón, 99.

215
00:18:15,730 --> 00:18:21,970
Aquí (10/7), se este fose C, o que tería que volver?

216
00:18:23,700 --> 00:18:29,630
[Estudante] 1. >> Si, sería un dato que 10/7 é dividir números enteiros 2.

217
00:18:29,630 --> 00:18:32,910
Un enteiro dividido por un número enteiro vai voltar un enteiro.

218
00:18:32,910 --> 00:18:37,750
Non pode voltar un calquera punto que sería, por iso só vai voltar 1.

219
00:18:37,750 --> 00:18:46,120
Aquí impresión (10/7), que vai realmente interpretar isto.

220
00:18:46,120 --> 00:18:53,760
E isto significa que se o quere facer redondeo enteiro e cousas así,

221
00:18:53,760 --> 00:18:59,950
cómpre facer impresión (planta (10/7));

222
00:18:59,950 --> 00:19:08,460
C pode ser estraño que pode confiar en truncamento enteiro regularmente,

223
00:19:08,460 --> 00:19:12,260
pero en PHP non pode porque el será automaticamente transformalo en un coche alegórico.

224
00:19:13,430 --> 00:19:17,610
E despois (7 + true), o que pensas que vai ser?

225
00:19:18,550 --> 00:19:23,640
Estou supoñendo que 8 se vai interpretar como unha verdadeira.

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

227
00:19:25,740 --> 00:19:31,710
>> Entón, calquera cousa que fixemos nos últimos 10 minutos que nunca debe facer absolutamente.

228
00:19:31,710 --> 00:19:39,870
Vai ver o código que fai iso.

229
00:19:39,870 --> 00:19:42,700
Ela non ten que ser tan sinxelo coma este.

230
00:19:42,700 --> 00:19:47,240
Pode ter dúas variables, e unha variable pasa a ser unha cadea

231
00:19:47,240 --> 00:19:51,310
e outra variable pasa a ser un int, e despois de engadir estas variables xuntas.

232
00:19:51,310 --> 00:20:00,120
Dende o PHP é tipada dinamicamente e non vai facer calquera tipo de verificación para ti

233
00:20:00,120 --> 00:20:03,640
e unha vez que é feblemente tipada e xa que só ha automaticamente xogar esas cousas xuntos

234
00:20:03,640 --> 00:20:11,490
e todo vai funcionar, é difícil incluso saber que esta variable debe ser unha secuencia de agora,

235
00:20:11,490 --> 00:20:14,930
por iso non debe engadir a esta variable, que é un enteiro.

236
00:20:18,780 --> 00:20:24,560
A mellor práctica é unha variable é unha cadea, mantelo como unha cadea para sempre.

237
00:20:24,560 --> 00:20:26,980
Se a variable é un int, mantelo como un int para sempre.

238
00:20:26,980 --> 00:20:30,770
Se queres tratar con números enteiros e cadeas,

239
00:20:30,770 --> 00:20:36,970
pode usar varsint - que é JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Fago iso o tempo. PHP e JavaScript eu misturo todo.

241
00:20:42,520 --> 00:20:47,600
Entón intval vai voltar o valor enteiro dunha variable.

242
00:20:47,600 --> 00:20:56,550
Se pasar "print (intval ('123 ')), comeza 123.

243
00:21:06,820 --> 00:21:15,850
Intval si só non vai facer o cheque para nós que é exclusivamente un enteiro.

244
00:21:15,850 --> 00:21:20,460
O manual de PHP, hai só funcións tantas dispoñible,

245
00:21:20,460 --> 00:21:26,560
entón aquí eu creo que o que eu usaría é is_numeric primeiro.

246
00:21:26,560 --> 00:21:32,590
Estou supoñendo que retornou falso.

247
00:21:32,590 --> 00:21:35,780
Isto é outra cousa que temos que pasar por riba é. ===

248
00:21:37,850 --> 00:21:44,020
Entón is_numeric ('123df '), non pensaría que, como is_numeric.

249
00:21:44,020 --> 00:21:46,720
C, que tería que iterar sobre todos os personaxes

250
00:21:46,720 --> 00:21:50,410
e comprobar a ver se cada personaxe é o díxito ou o que quere.

251
00:21:50,410 --> 00:21:53,850
Aquí is_numeric vai facer por nós,

252
00:21:53,850 --> 00:21:56,520
e está retornando falso.

253
00:21:56,520 --> 00:22:02,120
Entón, cando eu impresa, é impreso nada, entón aquí estou comparando-a ver,

254
00:22:02,120 --> 00:22:05,490
Se ocorrer de lle ser falsa? E agora está imprimindo un.

255
00:22:05,490 --> 00:22:10,060
Ao parecer, el imprime un como verdadeiro en vez de imprimir certo como certo.

256
00:22:10,060 --> 00:22:15,790
Quere saber se podo facer print_r. Non, el aínda fai un.

257
00:22:15,790 --> 00:22:26,760
>> Volvendo ao ===, == aínda existe,

258
00:22:26,760 --> 00:22:32,260
e falar con Tommy vai dicir == é perfectamente ben.

259
00:22:32,260 --> 00:22:37,700
Eu vou dicir que == é terrible e nunca debe usar. ==

260
00:22:37,700 --> 00:22:44,870
A diferenza é que as cousas == compara

261
00:22:44,870 --> 00:22:48,450
onde pode ser certo aínda que eles non son do mesmo tipo,

262
00:22:48,450 --> 00:22:53,810
Considerando === compara cousas e primeiro, comprobar son eles mesmo tipo?

263
00:22:53,810 --> 00:22:58,010
Si Ok, agora eu vou ver se realmente comparar a ser igual.

264
00:22:58,010 --> 00:23:08,890
Comeza cousas estrañas como 10 é igual a - imos ver o que di.

265
00:23:08,890 --> 00:23:15,570
Entón ('10 '== '1 E1');

266
00:23:15,570 --> 00:23:17,980
Isto amosa certo.

267
00:23:17,980 --> 00:23:21,420
Alguén ten algún palpite que este retorna verdade?

268
00:23:25,180 --> 00:23:27,120
Non é só sobre iso. Quizais esta sexa unha información.

269
00:23:27,120 --> 00:23:33,170
Pero se eu cambiar isto para un f - Droga! Eu sigo usando comiñas dobres.

270
00:23:33,170 --> 00:23:38,780
A razón das aspas están gritando comigo é porque eu coloque iso comiñas.

271
00:23:38,780 --> 00:23:43,850
Entón, eu podería escapar as comiñas aquí, pero aspas facelo máis fácil.

272
00:23:43,850 --> 00:23:49,120
Entón ('10 '== '1 F1'); non imprime verdade. ('10 '== '1 E1'); imprime verdade.

273
00:23:49,120 --> 00:23:56,330
[Estudante] É Hex? >> Non é Hex, pero está preto que é como -

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

275
00:24:01,060 --> 00:24:07,950
El recoñece como 1e1 1 * 10 ^ 1, ou o que sexa.

276
00:24:07,950 --> 00:24:11,510
Estes son números enteiros iguais.

277
00:24:11,510 --> 00:24:15,930
Se facemos === entón vai ser falsa.

278
00:24:15,930 --> 00:24:28,490
Eu realmente non teño idea se nós facemos o que dicir == (10 e '10abc ');? Todo ben. Entón, iso é verdade.

279
00:24:28,490 --> 00:24:35,940
Así como cando fixo (10 + '10abc '), e que sería 20,

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

281
00:24:38,800 --> 00:24:45,350
Peor aínda son cousas como (falsa == NULL); é verdade

282
00:24:45,350 --> 00:24:52,210
ou (falso == 0); é certa, (falso == []);

283
00:24:52,210 --> 00:25:00,970
Hai casos estraños de - Isto é un deses casos estraños.

284
00:25:00,970 --> 00:25:08,110
Teña en conta que (false == []); é verdade.

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

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

287
00:25:16,090 --> 00:25:19,090
Entón == non é de forma transitiva.

288
00:25:19,090 --> 00:25:26,830
pode ser igual a un b pode ser igual a C,

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

290
00:25:29,340 --> 00:25:35,580
Iso é unha abominação para min, e ten que usar. ===

291
00:25:35,580 --> 00:25:38,590
[Alumno] Podemos facer! == Tamén? >> [Bowden] Si

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

293
00:25:44,600 --> 00:25:48,230
Isto é, en realidade, trouxo na especificación pset

294
00:25:48,230 --> 00:25:52,000
onde unha morea de retorno funcións -

295
00:25:52,000 --> 00:25:53,890
O manual de PHP é bo sobre iso.

296
00:25:53,890 --> 00:25:59,140
Ela coloca nunha gran caixa vermella "Isto pode voltar falso se non hai un erro."

297
00:25:59,140 --> 00:26:03,940
Pero volvendo 0 é unha cousa perfectamente razoable para volver.

298
00:26:03,940 --> 00:26:08,250
Debería calquera función que se espera para voltar un enteiro.

299
00:26:11,250 --> 00:26:17,880
Imos dicir que esta función debe contar o número de liñas nun arquivo ou algo así.

300
00:26:17,880 --> 00:26:23,490
En circunstancias normais, pasa esta función dun ficheiro

301
00:26:23,490 --> 00:26:27,120
e que vai voltar un enteiro que representa o número de liñas.

302
00:26:27,120 --> 00:26:30,820
Entón, 0 é un número perfectamente razoable o arquivo é só baleiro.

303
00:26:30,820 --> 00:26:36,810
Pero o que se pasar un arquivo válido ea función pasa a retornar falso

304
00:26:36,810 --> 00:26:38,860
se pasar un arquivo válido?

305
00:26:38,860 --> 00:26:46,500
Se acaba de facer == non está diferenciando o caso entre ficheiro válido e arquivo baleiro.

306
00:26:48,870 --> 00:26:51,350
Usar sempre. ===

307
00:26:55,690 --> 00:26:58,000
Isto é todo isto.

308
00:26:58,000 --> 00:27:01,660
>> No PHP, tipo de matriz é diferente do que está afeito en C.

309
00:27:01,660 --> 00:27:06,650
En realidade, xa debe ter notado esta por riba de cando viu que este é o tipo Array.

310
00:27:06,650 --> 00:27:15,640
A sintaxe soporte é novo no PHP 5.4, que é a máis nova versión do PHP.

311
00:27:15,640 --> 00:27:36,960
Antes isto, sempre que escribir array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Ese foi o constructor para unha matriz.

313
00:27:41,160 --> 00:27:45,950
Agora PHP finalmente chegou preto para ver a sintaxe agradable de só corchetes,

314
00:27:45,950 --> 00:27:50,900
que é só moito mellor array.

315
00:27:50,900 --> 00:27:54,480
Pero, considerando o PHP 5.4 é a versión máis recente,

316
00:27:54,480 --> 00:27:59,090
podes atopar sitios que non teñen sequera PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Durante o verán, corre para este problema en PHP 5.3 era o que tiñamos no aparello,

318
00:28:08,220 --> 00:28:14,480
pero o servidor que implantado todo o libro o noso grao e enviar todas as cousas que a

319
00:28:14,480 --> 00:28:16,750
era PHP 5.4.

320
00:28:16,750 --> 00:28:23,060
Non sabendo diso, realizamos en 5,3, empurrou para 5,4,

321
00:28:23,060 --> 00:28:25,660
e agora, de súpeto ningún do noso código funciona

322
00:28:25,660 --> 00:28:28,680
porque non pasou ser cambios entre 5,3 e 5,4

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

324
00:28:31,030 --> 00:28:35,770
e nós temos que ir e corrixir todas as nosas cousas que non funcionan para PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
Para esta clase, xa que o aparello ten PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
é perfectamente posible usar corchetes.

327
00:28:47,240 --> 00:28:50,440
Pero se está mirando para as cousas ao redor de Internet,

328
00:28:50,440 --> 00:28:54,880
Se está a buscar algún tipo de material matriz, o máis probable é que vai ver

329
00:28:54,880 --> 00:29:02,020
o feitizo fóra sintaxe constructor de matriz dende que existe desde o PHP naceu

330
00:29:02,020 --> 00:29:07,340
e sintaxe de corchetes ten sido en torno dos últimos dous meses

331
00:29:07,340 --> 00:29:10,020
ou sempre que 5,4 veu ao redor.

332
00:29:10,020 --> 00:29:12,710
Isto é como índice de ti.

333
00:29:12,710 --> 00:29:30,610
Así como en C como se fose o índice por corchetes como $ array [0] array $ [1], array $ [2]

334
00:29:30,610 --> 00:29:36,320
vostede índice da mesma forma ocorrer de ter os seus índices sendo cordas.

335
00:29:36,320 --> 00:29:40,440
Matriz para array $ ['a'] e $ ['b'].

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

337
00:29:52,490 --> 00:29:59,870
El probablemente ha xerar un aviso, pero aínda funciona. PHP tende a facelo.

338
00:29:59,870 --> 00:30:04,890
Ela tende a só: "Eu estou indo a aviso-lo sobre iso, pero eu só vou seguir

339
00:30:04,890 --> 00:30:07,550
"E facer o que eu poida."

340
00:30:07,550 --> 00:30:11,500
El probablemente ha traducir isto para unha cadea,

341
00:30:11,500 --> 00:30:15,000
, Pero é posible que, nalgún momento no pasado alguén dixo

342
00:30:15,000 --> 00:30:20,180
definir b ser 'Ola Mundo ".

343
00:30:20,180 --> 00:30:28,740
Entón, agora b podería ser unha constante de matriz e US $ [b] vai ser realmente facendo "Ola Mundo".

344
00:30:28,740 --> 00:30:32,380
Eu creo que neste momento, ou polo menos as nosas opcións PHP,

345
00:30:32,380 --> 00:30:37,870
se tentar índice nunha matriz e esa clave non existe, el ha falla.

346
00:30:37,870 --> 00:30:40,150
Eu non creo que iso só vai te avisar.

347
00:30:40,150 --> 00:30:44,560
Ou polo menos, pode configuralo para que non só sinalando-lo, só en liña recta ata fallar.

348
00:30:44,560 --> 00:30:49,290
>> A xeito no que comprobar a ver se hai realmente un tal contido é isset.

349
00:30:49,290 --> 00:30:54,690
Entón isset ($ array ['Ola Mundo']) retornará falso.

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

351
00:31:06,830 --> 00:31:09,880
Pode mesturar estas sintaxe.

352
00:31:15,060 --> 00:31:22,440
Estou seguro de que esa matriz acabaría sendo é - Podemos probalo.

353
00:31:43,290 --> 00:31:45,700
Oh, eu teño PHPWord.

354
00:31:53,960 --> 00:32:00,260
Este é mesturar a sintaxe onde se especifica que é a clave

355
00:32:00,260 --> 00:32:03,330
e non especificar o que está a clave.

356
00:32:03,330 --> 00:32:05,520
Entón 3 aquí é un valor.

357
00:32:05,520 --> 00:32:08,080
Non dixo explicitamente que a súa clave é que vai ser.

358
00:32:08,080 --> 00:32:11,670
¿Que pensas da súa clave vai ser?

359
00:32:11,670 --> 00:32:21,410
[Estudante] 0. >> Estou supoñendo 0 só porque é o primeiro que non especificou.

360
00:32:21,410 --> 00:32:23,500
Podemos realmente facer un par deses casos.

361
00:32:23,500 --> 00:32:28,030
Entón print_r e imprimir recursiva. El ha imprimir toda a matriz.

362
00:32:28,030 --> 00:32:32,700
Sería imprimir subarrays da matriz, se houbese algún.

363
00:32:32,700 --> 00:32:36,630
Entón print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
El se parece con el deu 0.

365
00:32:38,810 --> 00:32:43,530
En realidade, hai algo a ter en conta aquí, pero imos volver a el en un segundo.

366
00:32:43,530 --> 00:32:45,850
Pero o que se ocorrer de eu facer este índice 1?

367
00:32:45,850 --> 00:32:51,170
PHP non fai diferenza entre os índices de cordas e índices enteiros,

368
00:32:51,170 --> 00:33:00,280
por iso neste momento teño só definido un índice 1 e podo facer tanto a matriz $ [1] e $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
e será o mesmo índice e a mesma clave.

370
00:33:06,250 --> 00:33:13,000
Entón agora o que pensas 3 vai ser? >> [Alumno] 2. >> [Bowden] Estou supoñendo 2.

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

372
00:33:18,690 --> 00:33:24,790
O que se fixésemos iso é 10, e 4? ¿Que pensas que o índice de 3 vai ser?

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

374
00:33:29,110 --> 00:33:33,060
O meu palpite sobre o que o PHP fai - e eu creo que xa vin iso antes -

375
00:33:33,060 --> 00:33:39,760
É só se mantén informado do que o maior índice numérico que se usa ata agora é.

376
00:33:39,760 --> 00:33:44,230
Iso nunca vai asignar un índice de secuencia para 3. Será sempre un índice numérico.

377
00:33:44,230 --> 00:33:47,690
Por iso, mantén o control do máis alto é asignado ata agora, que pasa a ser 10,

378
00:33:47,690 --> 00:33:52,540
e vai dar 11-3.

379
00:33:52,540 --> 00:34:02,110
O que eu dixen antes, observe a forma como está a imprimir esa matriz.

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

381
00:34:06,850 --> 00:34:09,790
Ou mesmo imos facer -

382
00:34:15,760 --> 00:34:22,489
Coido que eu non coloque a 0, pero é a impresión 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
E se eu cambiar aquí? Ou imos realmente cambiar estes 2.

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

385
00:34:31,940 --> 00:34:41,270
Matrices de PHP non son como a súa táboa estándar de hash.

386
00:34:41,270 --> 00:34:45,570
É perfectamente razoable pensar neles como táboas de hash do 99% do tempo.

387
00:34:45,570 --> 00:34:53,790
Pero nas súas táboas de hash non hai sentido da orde en que as cousas estaban inseridos.

388
00:34:53,790 --> 00:34:56,639
Así, logo que inserir na táboa hash,

389
00:34:56,639 --> 00:35:00,590
asumir que non hai lista de ligazóns e pode xulgar dentro dunha lista ligada

390
00:35:00,590 --> 00:35:03,980
a cal foi inserida en primeiro lugar.

391
00:35:03,980 --> 00:35:10,060
Pero aquí estamos inseridos dous primeiro e sabe cando e imprimir esa matriz que 2 ven en primeiro lugar.

392
00:35:10,060 --> 00:35:13,090
Non imprimir lo en só un fin calquera.

393
00:35:13,090 --> 00:35:17,550
A estrutura de datos técnicos que está a usar é un mapa ordenado,

394
00:35:17,550 --> 00:35:24,690
así que mapea claves para valores e recorda a orde en que as claves foron inseridas.

395
00:35:24,690 --> 00:35:31,600
Basicamente é para algunhas complicacións en que é aburrido para realmente -

396
00:35:31,600 --> 00:35:34,510
Imos dicir que ten unha matriz 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
e quere aproveitar índice 2.

398
00:35:37,700 --> 00:35:47,750
Unha forma de facelo, imos ver o 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
Unset acontece para eliminar as dúas variables e índices da matriz.

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

402
00:35:58,630 --> 00:36:03,430
Agora, o que iso vai parecer? 2 é só ir aínda que, de modo que é perfectamente ben.

403
00:36:03,430 --> 00:36:11,670
Máis irritante é se quere que as cousas realmente como unha matriz.

404
00:36:11,670 --> 00:36:14,910
Vou poñer números aleatorios.

405
00:36:14,910 --> 00:36:20,400
Agora, observe os meus índices.

406
00:36:20,400 --> 00:36:26,860
Eu quero que sexa só como unha matriz C, onde vai de 0 a duración - 1

407
00:36:26,860 --> 00:36:30,810
e podo iterar sobre el como tal.

408
00:36:30,810 --> 00:36:38,520
Pero así que eu eliminar o segundo índice, que estaba no índice 3 non agora se fixo índice 2.

409
00:36:38,520 --> 00:36:44,790
En vez diso, só elimina ese índice e agora vai de 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Isto é perfectamente razoable.

411
00:36:48,740 --> 00:36:53,950
É só irritante e ten que facer cousas como emenda matriz. Si

412
00:36:53,950 --> 00:36:57,200
>> [Alumno] O que sucedería se tivese un loop

413
00:36:57,200 --> 00:36:59,630
e quería pasar por riba de todos os elementos?

414
00:36:59,630 --> 00:37:02,290
Cando bateu dous, sería renderse sempre?

415
00:37:02,290 --> 00:37:10,150
Iteração sobre unha matriz. Hai dúas formas de facelo.

416
00:37:10,150 --> 00:37:12,770
Podes usar un estándar para loop.

417
00:37:12,770 --> 00:37:22,000
Esta é outra complexidade do PHP.

418
00:37:22,000 --> 00:37:27,420
A maioría das linguaxes, eu diría, teñen algún tipo de lonxitude ou len ou algo

419
00:37:27,420 --> 00:37:30,470
indica a lonxitude dunha matriz.

420
00:37:30,470 --> 00:37:32,820
O PHP é contar.

421
00:37:32,820 --> 00:37:36,160
Entón count ($ array); $ i + +)

422
00:37:36,160 --> 00:37:42,950
Nós só impresión ($ array [$ i]);

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

424
00:37:48,820 --> 00:37:51,610
El só vai fallar.

425
00:37:51,610 --> 00:38:03,020
Esta é a razón que para a maior parte, nunca debe iterar sobre unha matriz coma este.

426
00:38:03,020 --> 00:38:07,110
Pode ser unha esaxeración, pero nunca debe iterar sobre unha matriz como esta

427
00:38:07,110 --> 00:38:19,410
porque o PHP ofrece a súa sintaxe foreach onde foreach (array $ como $ elemento).

428
00:38:19,410 --> 00:38:31,830
Agora, se nós imprimir ($ item); - nós discutir iso nun segundo - que funciona perfectamente ben.

429
00:38:31,830 --> 00:38:38,960
O xeito que foreach está a traballar é o primeiro argumento é a matriz que está iterando.

430
00:38:38,960 --> 00:38:44,060
E o segundo argumento, elemento, a través de cada paso do loop

431
00:38:44,060 --> 00:38:52,690
que vai asumir a seguinte cousa na matriz. Entón lembre-se a matriz ten unha orde.

432
00:38:52,690 --> 00:38:55,690
A primeira vez a través do loop for, o elemento será 123

433
00:38:55,690 --> 00:38:59,540
, El ha ser de 12, a continuación, será de 13, el ha ser de 23, entón será 213.

434
00:38:59,540 --> 00:39:04,670
As cousas están realmente estraño cando fai algo así como foreach.

435
00:39:04,670 --> 00:39:07,480
Imos ver o que pasa, porque nunca debe facelo.

436
00:39:07,480 --> 00:39:13,320
E se nós unset ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
Que probablemente foi o esperado.

438
00:39:26,030 --> 00:39:30,950
Vostede está interactuando sobre esta matriz, e cada vez que está desconfigurar o primeiro índice.

439
00:39:30,950 --> 00:39:39,720
Entón, para o índice 0, o primeiro elemento, asume valor 0, polo que vai ser 123.

440
00:39:39,720 --> 00:39:44,630
Pero dentro do loop que unset Índice 1, o que significa 12 está desaparecido.

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

442
00:39:57,480 --> 00:40:03,580
PHP_EOL é só de nova liña, pero é tecnicamente máis portátil

443
00:40:03,580 --> 00:40:08,890
dende novas liñas en Windows é diferente de novas liñas en Mac e Unix.

444
00:40:08,890 --> 00:40:18,040
En Windows nova liña é \ r \ n, mentres que en calquera outro lugar que tende só para ser \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL está configurado para que el usa o que quere que a nova liña do seu sistema.

446
00:40:25,150 --> 00:40:29,310
Así que imprimir. Non imos print_r ($ array) ao final.

447
00:40:32,830 --> 00:40:37,390
Eu non tiña idea de que iso sería o comportamento.

448
00:40:41,740 --> 00:40:48,960
Elemento aínda asume o valor de 12 aínda que unset 12 antes de nós sempre para el a partir da matriz.

449
00:40:52,770 --> 00:40:58,840
Non Tomé miña palabra sobre iso, pero parece que foreach crea unha copia da matriz

450
00:40:58,840 --> 00:41:02,160
e entón o elemento asume todos os valores que a copia.

451
00:41:02,160 --> 00:41:07,760
Así, mesmo se cambiar a matriz dentro do loop for,

452
00:41:07,760 --> 00:41:17,240
non vai se importar. Elemento será asumir os valores orixinais.

453
00:41:17,240 --> 00:41:19,240
Imos tentar desarmar-lo.

454
00:41:19,240 --> 00:41:24,460
E este é de R $ array [1] = "Ola";

455
00:41:24,460 --> 00:41:31,770
Mesmo que poñer "Ola" para a matriz, nunca elemento leva ese valor.

456
00:41:31,770 --> 00:41:37,430
Hai outra sintaxe para foreach lazos

457
00:41:37,430 --> 00:41:45,900
onde poñer dúas variables separadas por unha frecha.

458
00:41:45,900 --> 00:41:49,680
Esta primeira variable será a clave deste valor,

459
00:41:49,680 --> 00:41:53,050
e esta segunda variable será o mesmo elemento exacto.

460
00:41:53,050 --> 00:42:01,610
Isto non é interesante aquí, pero se volvemos ao noso caso orixinal de 'a' -> 1,

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

462
00:42:06,090 --> 00:42:14,470
aquí só iterar para cada matriz como elemento, o elemento será unha cada vez.

463
00:42:14,470 --> 00:42:18,170
Pero se nós tamén queremos saber a clave asociada con este elemento

464
00:42:18,170 --> 00:42:25,230
despois facemos as $ clave -> elemento $.

465
00:42:25,230 --> 00:42:31,980
Entón agora podemos facer impresión (tecla $. ':'.

466
00:42:31,980 --> 00:42:39,380
Agora está iterando e impresión de cada clave eo seu valor asociado.

467
00:42:39,380 --> 00:42:47,030
>> Unha cousa adicional que podemos facer en foreach loops é que pode ver esta sintaxe.

468
00:42:47,030 --> 00:42:54,770
E comercial antes de nomes de variables tenden a ser como o PHP fai referencias.

469
00:42:54,770 --> 00:43:00,460
Onde as referencias son moi semellantes aos punteiros,

470
00:43:00,460 --> 00:43:04,820
non ten punteiros, entón non xestione a memoria directamente.

471
00:43:04,820 --> 00:43:12,620
Pero ten referencias onde unha variable refírese a mesma cousa que outra variable.

472
00:43:12,620 --> 00:43:21,450
Aquí dentro, imos facer $ elemento. Imos volver 1, 10.

473
00:43:21,450 --> 00:43:28,800
Imos facer $ item + +; que aínda existe en PHP. Aínda pode facer + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Eu teño que imprimir lo. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
Nós imprimir 2, 11.

476
00:43:42,730 --> 00:43:49,560
Se eu tivese feito foreach (array $ como $ item) entón o elemento será o valor 1

477
00:43:49,560 --> 00:43:54,190
por primeira vez a través do loop. El ha incrementar 1-2 e despois estamos a facer.

478
00:43:54,190 --> 00:43:57,260
Entón vai pasar a segunda pasaxe do lazo e ese elemento é de 10.

479
00:43:57,260 --> 00:44:01,570
É elemento de incrementos a 11, e despois que acabou xogado fóra.

480
00:44:01,570 --> 00:44:06,670
Entón nós print_r ($ array), e imos ver o que este é só un de 10.

481
00:44:06,670 --> 00:44:09,070
Así, o incremento que fixemos foi perdido.

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

483
00:44:13,410 --> 00:44:21,910
agora este elemento é o mesmo elemento como este aquí. É a mesma cousa.

484
00:44:21,910 --> 00:44:26,820
Entón elemento de R $ + + está modificando matriz 0.

485
00:44:29,330 --> 00:44:41,850
Basicamente, vostede tamén pode facer $ k -> array $ elemento e pode facer [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Así, outra forma de facelo, somos libres para modificar elemento,

487
00:44:48,650 --> 00:44:54,070
pero iso non vai cambiar a nosa matriz orixinal.

488
00:44:54,070 --> 00:44:59,720
Pero se usamos k, que é a nosa clave, entón podemos só o índice na nosa matriz usando a clave

489
00:44:59,720 --> 00:45:01,530
e incrementar iso.

490
00:45:01,530 --> 00:45:05,410
Esta máis directamente modifica nosa matriz orixinal.

491
00:45:05,410 --> 00:45:10,690
Pode até facelo por algún motivo quere que a capacidade de modificar -

492
00:45:10,690 --> 00:45:13,510
En realidade, iso é perfectamente razoable.

493
00:45:13,510 --> 00:45:16,020
Non quería ter que escribir $ array [$ k] + +,

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

495
00:45:27,890 --> 00:45:30,620
entón incrementar elemento e, a continuación, imprimir a nosa matriz.

496
00:45:30,620 --> 00:45:36,290
Entón agora o que esperamos print_r facer? Que valores deben ser impresos?

497
00:45:36,290 --> 00:45:43,770
[Estudante] 2 e 10. >> [Bowden] Só a clave era 'a' nós realmente imprimir iso.

498
00:45:51,940 --> 00:45:55,670
>> Vostede, probablemente, moi raramente, ou nunca, será necesario definir funcións en PHP,

499
00:45:55,670 --> 00:46:03,370
pero podes ver algo semellante, onde define unha función como calquera función.

500
00:46:03,370 --> 00:46:09,900
Normalmente diría ($ foo $ bar) e, entón, establecer que sexa o que sexa.

501
00:46:09,900 --> 00:46:17,580
Pero se eu fai iso, entón iso significa que o que chama de calquera cousa,

502
00:46:17,580 --> 00:46:25,110
calquera que chama Baz, de xeito que o primeiro argumento pasado para Baz pode ser cambiado.

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

504
00:46:38,100 --> 00:46:48,020
e aquí dentro, imos facer Baz ($ item);

505
00:46:48,020 --> 00:46:52,250
Agora estamos chamando unha función.

506
00:46:52,250 --> 00:46:56,780
O argumento é tomado por referencia, o que significa que, se modificalo lo

507
00:46:56,780 --> 00:47:00,390
estamos modificando a cousa que foi pasado dentro

508
00:47:00,390 --> 00:47:04,420
E a impresión dese esperamos - a menos que eu errei sintaxe - temos 2, 11,

509
00:47:04,420 --> 00:47:06,300
así foi, en realidade, incrementado.

510
00:47:06,300 --> 00:47:08,790
Teña en conta que cómpre referencias en dous lugares.

511
00:47:08,790 --> 00:47:13,050
E se eu fixen iso? O que significa isto?

512
00:47:13,050 --> 00:47:15,810
[Alumno] vai cambiar. Si >>.

513
00:47:15,810 --> 00:47:18,290
Elemento é só unha copia do valor na matriz.

514
00:47:18,290 --> 00:47:26,670
Así, o artigo ha cambiar a 2, pero a matriz ['a'] aínda será 1.

515
00:47:26,670 --> 00:47:32,560
Ou o que se eu fai iso?

516
00:47:32,560 --> 00:47:39,260
Agora elemento é enviado como copia de Baz.

517
00:47:39,260 --> 00:47:46,330
Polo tanto, a copia do argumento será incrementado a 2,

518
00:47:46,330 --> 00:47:49,240
pero o elemento en si nunca foi incrementado a 2.

519
00:47:49,240 --> 00:47:52,880
E elemento é o mesmo que o soporte de matriz que sexa,

520
00:47:52,880 --> 00:47:55,380
de xeito que a matriz nunca foi incrementado.

521
00:47:55,380 --> 00:47:57,960
Así, ambos os lugares precisan.

522
00:47:57,960 --> 00:48:03,830
>> PHP é xeralmente moi intelixente sobre iso.

523
00:48:03,830 --> 00:48:06,570
Podes pensar que quero pasar por referencia -

524
00:48:06,570 --> 00:48:09,560
Esta foi realmente unha pregunta sobre unha das serie de exercicios.

525
00:48:09,560 --> 00:48:14,480
Foi unha cousa questions.txt onde di:

526
00:48:14,480 --> 00:48:19,280
Por que quere pasar esa estrutura por referencia?

527
00:48:19,280 --> 00:48:21,250
Cal foi a resposta?

528
00:48:21,250 --> 00:48:25,100
[Alumno] Entón non tes que copiar algo grande. Si >>.

529
00:48:25,100 --> 00:48:32,920
Unha estrutura pode ser arbitrariamente grande, e cando pasar a estrutura como un argumento

530
00:48:32,920 --> 00:48:36,800
precisa copiar a estrutura enteira para pasalo para a función,

531
00:48:36,800 --> 00:48:40,410
mentres que se só pasar a estrutura por referencia

532
00:48:40,410 --> 00:48:46,530
entón só precisa copiar un enderezo de 4 bytes como argumento para a función.

533
00:48:48,520 --> 00:48:52,320
PHP é un pouco máis intelixente do que iso.

534
00:48:52,320 --> 00:49:00,650
Se ten algunha función e eu pasar a el unha serie de cousas 1000,

535
00:49:00,650 --> 00:49:03,990
Isto significa que vai ter que copiar todo 1.000 destas cousas

536
00:49:03,990 --> 00:49:10,450
para pasar á función? Non ten que facer iso inmediatamente.

537
00:49:10,450 --> 00:49:15,940
Dentro desta función nunca realmente modifica foo,

538
00:49:15,940 --> 00:49:22,660
por iso, se ($ foo === 'Ola') return true.;

539
00:49:22,660 --> 00:49:26,460
Teña en conta que de feito nunca modificou o interior argumento desta función,

540
00:49:26,460 --> 00:49:30,010
o que significa que todo o que foi pasado como nunca foo precisa ser copiado

541
00:49:30,010 --> 00:49:32,100
porque non é modificalo.

542
00:49:32,100 --> 00:49:39,240
Así, a modo PHP obras e os argumentos son sempre pasados ​​por referencia

543
00:49:39,240 --> 00:49:42,170
ata que realmente tentar modificalo.

544
00:49:42,170 --> 00:49:51,160
Agora, se eu digo $ foo + +, que vai agora facer unha copia do foo orixinal e modificar a copia.

545
00:49:51,160 --> 00:49:53,090
Isto aforrar moito tempo.

546
00:49:53,090 --> 00:49:58,210
Se nunca está tocando esta enorme variedade, nunca realmente modificalo-lo,

547
00:49:58,210 --> 00:50:02,360
non necesita para facer a copia,

548
00:50:02,360 --> 00:50:06,640
mentres que se nós só poñemos ese comercial que significa que nin sequera copia-lo

549
00:50:06,640 --> 00:50:08,640
mesmo se modificalo.

550
00:50:08,640 --> 00:50:10,680
Este comportamento é chamado de copia na gravación.

551
00:50:10,680 --> 00:50:17,380
Vai velo noutros lugares, especialmente se aproveitar un curso de sistema operativo.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write é un estándar bastante usual que non precisa facer unha copia de algo

553
00:50:23,880 --> 00:50:26,650
a menos que sexa realmente cambiando. Si

554
00:50:26,650 --> 00:50:29,520
[Alumno] E se tivese o incremento dentro da proba,

555
00:50:29,520 --> 00:50:33,700
tan só o elemento 1 de 1000 terá que ser cambiado?

556
00:50:33,700 --> 00:50:38,770
Non estou seguro.

557
00:50:38,770 --> 00:50:51,250
Coido que sería copiar a cousa toda, pero é posible que el é intelixente o suficiente para que -

558
00:50:51,250 --> 00:51:00,020
En realidade, o que eu estou pensando é imaxinar que tiñamos unha matriz que queda así: $ array2 = [

559
00:51:00,020 --> 00:51:11,000
Entón índice de 'a' é unha matriz de [1 2 3 4], índice e 'b' é unha matriz de calquera cousa.

560
00:51:11,000 --> 00:51:15,380
Eu teño comas entre todos estes. Imaxina que hai dous puntos.

561
00:51:15,380 --> 00:51:21,210
A continuación, 'c' é o 3 valor.

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

563
00:51:26,290 --> 00:51:33,440
Agora imos dicir que temos $ Baz ($ array2);

564
00:51:33,440 --> 00:51:36,540
onde Baz non tomar esta referencia.

565
00:51:43,510 --> 00:51:47,370
Entón $ foo ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
Este é un exemplo onde estamos pasando array2 como un argumento

567
00:51:52,340 --> 00:51:57,010
e en seguida, é a modificación dun índice específico da matriz, incrementando-lo.

568
00:51:57,010 --> 00:52:01,090
Eu honestamente non teño idea do que o PHP vai facer.

569
00:52:01,090 --> 00:52:07,200
Pode facilmente facer unha copia de toda a cousa, pero se é intelixente,

570
00:52:07,200 --> 00:52:15,030
vai facer unha copia destas chaves, onde esta terá o seu valor distinto

571
00:52:15,030 --> 00:52:20,620
pero esta aínda pode apuntar para o mesmo matriz 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
e isto pode apuntar para o mesmo matriz.

573
00:52:22,320 --> 00:52:24,170
Vou iPad lo.

574
00:52:28,900 --> 00:52:45,950
Pasamos esa matriz onde este cara puntos 3, que apunta a cara [1,2,3,4],

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

576
00:52:51,350 --> 00:52:58,590
Agora que estamos pasando para Baz, estamos modificando iso.

577
00:52:58,590 --> 00:53:03,550
Se o PHP é intelixente, pode só facer -

578
00:53:11,850 --> 00:53:18,230
Aínda tiña que copiar algunha memoria, pero se houbese esas subarrays enormes aninhadas

579
00:53:18,230 --> 00:53:21,560
Nós non precisamos copiar.

580
00:53:21,560 --> 00:53:27,530
Eu non sei se é iso que fai, pero podo imaxinar que está facendo iso.

581
00:53:29,050 --> 00:53:36,690
Esta tamén é unha vantaxe moi grande de C sobre PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP fai a vida moito máis fácil para unha morea de cousas,

583
00:53:40,320 --> 00:53:45,060
pero medio que ten absolutamente ningunha idea de como ha executar

584
00:53:45,060 --> 00:53:52,530
porque eu non teño ningunha idea debaixo do capó cando se está a facer estas copias de cousas,

585
00:53:52,530 --> 00:53:55,170
oh, é que vai ser unha copia de tempo constante,

586
00:53:55,170 --> 00:54:01,140
É só vai cambiar un punteiro, que vai ser unha copia ridiculamente difícil lineal?

587
00:54:01,140 --> 00:54:03,000
E se non pode atopar espazo?

588
00:54:03,000 --> 00:54:06,760
Será que precisa entón para realizar a recolección de lixo para conseguir espazo un pouco máis?

589
00:54:06,760 --> 00:54:11,210
E recolección de lixo pode tomar arbitrariamente longo.

590
00:54:11,210 --> 00:54:13,600
C non ten que se preocupar con estas cousas.

591
00:54:13,600 --> 00:54:19,780
Cada liña que escribe pode razoar moi bonita sobre como vai realizar.

592
00:54:26,800 --> 00:54:29,150
>> Imos mirar para estes.

593
00:54:35,400 --> 00:54:37,520
Que bo é que non tes que tratar con funcións de hash,

594
00:54:37,520 --> 00:54:39,010
listas ligadas, ou algo así?

595
00:54:39,010 --> 00:54:41,980
Desde que traballo con táboas de hash é tan fácil agora, aquí está un puzzle divertido para traballar.

596
00:54:41,980 --> 00:54:45,920
Abrir un ficheiro chamado unique.php e nela escribir un programa PHP

597
00:54:45,920 --> 00:54:48,330
(Tamén coñecido como un "guión").

598
00:54:48,330 --> 00:54:55,700
Nós tendemos a chamalos de guións se son cousas pequenas que executa na liña de comandos.

599
00:54:55,700 --> 00:55:02,950
Basicamente, calquera linguaxe que non compilar, pero está indo a executar o arquivo executábel

600
00:55:02,950 --> 00:55:05,920
na liña de comandos, pode chamar este script executable.

601
00:55:05,920 --> 00:55:08,510
Eu podería moi ben escribir un programa en C que fai iso,

602
00:55:08,510 --> 00:55:12,300
pero eu non chamalo de un script desde que eu compilar e executar o binario.

603
00:55:12,300 --> 00:55:15,480
Pero este programa PHP imos chamar un script.

604
00:55:15,480 --> 00:55:23,830
Ou se escribiu en Python ou Perl ou Node.js ou calquera destas cousas,

605
00:55:23,830 --> 00:55:26,500
nós chama-los de todos os scripts porque executa-los na liña de comandos

606
00:55:26,500 --> 00:55:30,040
pero non recompila-los.

607
00:55:30,860 --> 00:55:33,400
Nós poderiamos facelo moi rapidamente.

608
00:55:36,960 --> 00:55:41,480
Nós non estamos indo a usar argv. Nós só explotar por iso.

609
00:55:41,480 --> 00:55:45,730
Chama-o único, escribir un programa.

610
00:55:45,730 --> 00:55:49,400
Pode asumir que a entrada contén unha palabra por liña.

611
00:55:49,400 --> 00:55:52,020
En realidade, argv será ben sinxelo de usar.

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

613
00:56:08,550 --> 00:56:13,750
Primeiro de todo, queremos comprobar se foron pasados ​​un argumento de liña de comandos.

614
00:56:13,750 --> 00:56:20,900
Así como sería de esperar argc e argv en C, aínda temos os en PHP.

615
00:56:20,900 --> 00:56:33,900
Entón, se ($ argc! == 2) entón eu non vou tratar con a impresión dunha mensaxe ou calquera cousa.

616
00:56:33,900 --> 00:56:37,340
Eu só vou saír, código de erro de 1.

617
00:56:37,340 --> 00:56:41,340
Eu tamén podería volver 1.

618
00:56:41,340 --> 00:56:53,180
Raramente en PHP está neste estado onde estamos -

619
00:56:53,180 --> 00:56:57,820
Normalmente, está en unha función chamada por unha función chamada por unha función chamada por unha función.

620
00:56:57,820 --> 00:57:02,070
E se algo sae mal e só quere saír todo enteiramente,

621
00:57:02,070 --> 00:57:05,680
saída só encerra o programa.

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

623
00:57:08,160 --> 00:57:10,700
Se vostede está en unha función dunha función nunha función en función

624
00:57:10,700 --> 00:57:17,540
e quere só matar o programa, pode chamar de saída e vai saír.

625
00:57:17,540 --> 00:57:23,120
Pero en PHP é aínda máis raro que estamos neste nivel superior.

626
00:57:23,120 --> 00:57:26,090
Normalmente estamos dentro dalgún tipo de función, por iso chamamos de saída

627
00:57:26,090 --> 00:57:29,650
de xeito que non temos que volver a unha cousa que, entón, entende que hai un erro

628
00:57:29,650 --> 00:57:32,270
así que retorna si recoñece que houbo un erro.

629
00:57:32,270 --> 00:57:35,270
Non queren tratar con isto, entón saír (1);

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

631
00:57:38,240 --> 00:57:44,000
>> Entón, o que queremos abrir queremos fopen.

632
00:57:44,000 --> 00:57:46,760
Os argumentos van ollar moi semellantes.

633
00:57:46,760 --> 00:57:51,600
Queremos fopen ($ argv [1], e queremos abrilo para a súa lectura.

634
00:57:51,600 --> 00:57:55,720
Que retorna un recurso que nós imos chamar f.

635
00:57:55,720 --> 00:58:02,180
Isto parece moi semellante á forma como C fai iso, agás que non temos que dicir * File.

636
00:58:02,180 --> 00:58:06,170
En vez diso, só dicir $ f. Okay.

637
00:58:06,170 --> 00:58:17,190
En realidade, eu creo que iso aínda nos dá unha información de PHP función chamada arquivo. Arquivo PHP.

638
00:58:17,190 --> 00:58:23,990
O que é que isto vai facer é ler un ficheiro nunha matriz.

639
00:58:23,990 --> 00:58:29,770
Non precisa aínda de fopen-lo. El vai facelo por vostede.

640
00:58:37,450 --> 00:58:43,700
Entón $ liñas = file ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Agora, todas as liñas do ficheiro son en liñas. Agora queremos clasificar as liñas.

642
00:58:49,680 --> 00:58:52,180
Como podemos clasificar as liñas?

643
00:58:52,180 --> 00:58:54,920
Nós clasificar as liñas.

644
00:58:54,920 --> 00:58:58,080
E agora podemos imprimilas los ou o que sexa.

645
00:58:58,080 --> 00:59:05,580
Probablemente o xeito máis doado é foreach ($ lines as $ liña) echo $ liña;

646
00:59:05,580 --> 00:59:10,960
[Alumno] non sería mesmo de cruzar as liñas, facendo referencia a algo en especie?

647
00:59:10,960 --> 00:59:28,850
Este é o lugar onde tipo pode ser definido como unha especie de función (+ $ array).

648
00:59:28,850 --> 00:59:32,650
Cando chama a función que non pase por referencia.

649
00:59:32,650 --> 00:59:36,900
É a función que define como tomalo como referencia.

650
00:59:36,900 --> 00:59:40,900
Este é, en realidade, exactamente o que deu mal

651
00:59:40,900 --> 00:59:46,220
cando poñemos todo nos nosos servidores cando fomos 5,3-5,4.

652
00:59:46,220 --> 00:59:53,800
Ata 5.4, iso era perfectamente razoable.

653
00:59:53,800 --> 00:59:58,740
Unha función non espera para levalo como referencia, pero pode pasar isto como referencia

654
00:59:58,740 --> 01:00:02,860
por iso, se a función non acontece para modificalo lo, aínda é modificado.

655
01:00:02,860 --> 01:00:05,850
A partir de 5.4, non debería facelo.

656
01:00:05,850 --> 01:00:11,740
Entón, agora a única forma de pasar por referencia é a función explícitamente o fai.

657
01:00:11,740 --> 01:00:19,840
Se non quere que para modificalo lo, entón tes que facer copy = $ $ liñas e copia pase.

658
01:00:19,840 --> 01:00:24,820
Entón, agora as liñas serán preservados e copia será alterado.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Eu podería ter sujado algo.

660
01:00:31,460 --> 01:00:33,190
'Tipo' inesperado.

661
01:00:38,320 --> 01:00:43,850
Non vai ser algo que fai iso para nós.

662
01:00:43,850 --> 01:00:45,820
El non está alí.

663
01:00:45,820 --> 01:00:52,140
Teña en conta que cando vostede lea a guía que o primeiro argumento é expected para ser un array

664
01:00:52,140 --> 01:00:56,490
e é tomado por referencia.

665
01:00:58,160 --> 01:01:03,540
Por que isto está reclamando comigo? Porque eu teño ese tipo de función aínda aquí que eu non quero.

666
01:01:03,540 --> 01:01:09,210
Ok, php.unique.php. Eu non pasar un argumento, porque eu non teño un arquivo.

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

668
01:01:13,560 --> 01:01:19,080
Aquí está test.php todos impresos nunha orde legal clasificados.

669
01:01:19,080 --> 01:01:24,600
Teña en conta que orde de clasificación é medio raro para un arquivo de código

670
01:01:24,600 --> 01:01:27,460
porque todas as nosas liñas en branco van vir en primeiro lugar

671
01:01:27,460 --> 01:01:30,190
entón van vir todos os nosos recortes de nivel 1

672
01:01:30,190 --> 01:01:33,360
despois veñen os nosos recortes non.

673
01:01:33,360 --> 01:01:38,620
Si >> [Alumno] Polo tanto, para o código fonte non foi pasado por referencia?

674
01:01:38,620 --> 01:01:42,240
É xeralmente pasados ​​por valor?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Cando chamar unha función, nunca determina se foi pasado por referencia.

676
01:01:50,240 --> 01:01:53,960
É a definición da función que determina se foi pasado por referencia.

677
01:01:53,960 --> 01:01:59,450
E mirando para a definición da función de clasificación ou só mirando para iso,

678
01:01:59,450 --> 01:02:02,820
que leva o argumento por referencia.

679
01:02:02,820 --> 01:02:07,160
Polo tanto, independentemente de se quere tomar por referencia, toma por referencia.

680
01:02:07,160 --> 01:02:10,200
El modifica a matriz no lugar.

681
01:02:10,200 --> 01:02:17,400
Este non é só admite. Non ten permiso para facelo. >> [Alumno] Ah, ok.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Iso, tipo vai ter liñas de referencia e modificalo.

683
01:02:22,410 --> 01:02:26,850
E, de novo, se non quere que faga iso, pode facer unha copia de tipo.

684
01:02:26,850 --> 01:02:35,850
Mesmo neste caso, a copia non é, en realidade, unha copia de liñas.

685
01:02:35,850 --> 01:02:40,620
El só apunta a mesma cousa, ata que primeiro é modificado,

686
01:02:40,620 --> 01:02:44,430
onde está primeiro vai ser modificado en función de clasificación,

687
01:02:44,430 --> 01:02:50,940
onde, porque é copia na gravación, agora unha copia do exemplar vai ser feita.

688
01:02:57,500 --> 01:03:04,250
Tamén pode facelo. Ese é o lugar que pode ver e comercial.

689
01:03:04,250 --> 01:03:07,190
Vostede ve isto loops foreach, ve-lo declaracións de función,

690
01:03:07,190 --> 01:03:10,040
e velo cando só a asignación de variables.

691
01:03:10,040 --> 01:03:12,350
Agora non realizamos nada, facendo iso

692
01:03:12,350 --> 01:03:15,600
porque copia e liñas son literalmente o mesmo.

693
01:03:15,600 --> 01:03:19,940
Podes empregar liñas e copiar alternativamente.

694
01:03:19,940 --> 01:03:25,430
Podes facer unset (copia $) e que non fai liñas unset,

695
01:03:25,430 --> 01:03:29,120
acaba de perder a súa referencia para o mesmo.

696
01:03:29,120 --> 01:03:33,440
Entón, a partir deste punto, agora liñas é a única forma que pode acceder liñas.

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
[Alumno] Completamente fóra topic, pero non ten que pechar o PHP - >> Non.

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

701
01:03:47,730 --> 01:03:53,790
[Bowden] Eu ía tan lonxe a punto de dicir que é unha mala práctica para pecha-las.

702
01:03:53,790 --> 01:03:57,580
Isto é probablemente unha esaxeración, especialmente en un script,

703
01:03:57,580 --> 01:04:03,740
pero imos ver o que acontece se eu facer iso.

704
01:04:03,740 --> 01:04:08,890
Que non fixo nada. E se eu quería - [suspira]

705
01:04:13,870 --> 01:04:16,960
Eu teño pasar un argumento.

706
01:04:19,000 --> 01:04:22,050
Shoot. Eu chamei o mal.

707
01:04:24,340 --> 01:04:28,310
Entón php.unique.php cun argumento.

708
01:04:28,310 --> 01:04:30,980
Agora eu non teño diso.

709
01:04:34,520 --> 01:04:37,740
Vou pasar para el un argumento válido.

710
01:04:37,740 --> 01:04:42,050
Este impreso o que é impresión.

711
01:04:45,260 --> 01:04:50,080
Eu estou imprimindo copia e copia non existe. Así liñas.

712
01:04:53,650 --> 01:04:58,270
É impreso todo, e entón entender todo ese lixo aquí,

713
01:04:58,270 --> 01:05:06,690
porque en nada PHP que está fóra das etiquetas PHP

714
01:05:06,690 --> 01:05:09,520
é só ir a ser impreso literalmente.

715
01:05:09,520 --> 01:05:18,050
É por iso que o HTML, é tan bo que podo facer div bla, bla, bla de clase ou o que sexa,

716
01:05:18,050 --> 01:05:25,140
bla, bla, bla e despois facer un código PHP e despois facer div final.

717
01:05:25,140 --> 01:05:36,460
E agora a impresión que eu recibín a miña div agradable enriba, o único que o PHP impreso, div na parte inferior.

718
01:05:36,460 --> 01:05:43,510
Desastroso cando algo así pasa, o que é bastante común,

719
01:05:43,510 --> 01:05:47,930
só unha nova liña perdida no fondo do arquivo.

720
01:05:47,930 --> 01:05:50,940
Non pensa que sería a de un gran negocio

721
01:05:50,940 --> 01:05:58,660
ata considerar o feito de que con navegadores -

722
01:05:58,660 --> 01:06:03,880
>> Como redirecciona traballo ou, basicamente, a obra de cabeceira,

723
01:06:03,880 --> 01:06:07,980
cando fai a súa conexión a un sitio web e envía de volta todos estes cabezallos e cousas

724
01:06:07,980 --> 01:06:12,020
como resposta 200 ou resposta redireccionar ou o que sexa,

725
01:06:12,020 --> 01:06:18,230
cabeceiras son válidos só ata o primeiro byte de datos é enviado.

726
01:06:18,230 --> 01:06:23,140
Pode redirixir miles de veces, pero, logo que o primeiro byte de datos é enviado

727
01:06:23,140 --> 01:06:26,120
non debería redireccionar novo.

728
01:06:26,120 --> 01:06:31,860
>> Se ten unha nova liña fixa na parte inferior dun ficheiro

729
01:06:31,860 --> 01:06:37,260
e digamos que use esa función e entón quere -

730
01:06:41,580 --> 01:06:52,870
Imos dicir que é outro arquivo que é index.php e require_once algo -

731
01:06:52,870 --> 01:06:56,920
Eu non podo pensar en un bo exemplo diso.

732
01:06:56,920 --> 01:07:04,740
O problema ocorre cando esta liña na parte inferior está eco.

733
01:07:04,740 --> 01:07:08,660
Non quere nada ser ecoado aínda.

734
01:07:10,820 --> 01:07:15,700
Aínda que non tiña a intención de quedar eco nada, algo que se repetiu

735
01:07:15,700 --> 01:07:17,990
e agora non debe enviar cabeceiras máis ningunha

736
01:07:17,990 --> 01:07:20,030
e está indo para obter queixas.

737
01:07:22,170 --> 01:07:24,420
Só non precisa desas etiquetas de peche.

738
01:07:24,420 --> 01:07:27,420
Se está a pensar en facer algo con HTML -

739
01:07:27,420 --> 01:07:30,490
e é perfectamente razoable a facer aquí o que div

740
01:07:30,490 --> 01:07:39,450
e entón, neste punto pode ou non pode inclui-los.

741
01:07:39,450 --> 01:07:41,590
Isto realmente non importa.

742
01:07:41,590 --> 01:07:45,450
Pero en scripts PHP é raro para a pechar.

743
01:07:45,450 --> 01:07:50,400
Cando todo está PHP, absolutamente todo,

744
01:07:50,400 --> 01:07:55,460
realmente non precisa pechalo / non debe pechalo.

745
01:08:02,030 --> 01:08:05,720
>> Tratar con cordas é moito máis agradable do que en C.

746
01:08:05,720 --> 01:08:09,470
No PHP, pode especificar unha cadea con comiñas simples ou dobres.

747
01:08:09,470 --> 01:08:12,820
Con aspas simples non pode usar "escape" secuencias.

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

749
01:08:19,920 --> 01:08:24,010
Entón printf é moi raro en PHP.

750
01:08:24,010 --> 01:08:32,290
Eu creo que eu ía usar printf se eu quería facer un tipo de cousas - que usou pset 5 sprintf ou o que quere.

751
01:08:32,290 --> 01:08:36,060
Pero quere facer 001.jpg 002.jpg e.

752
01:08:36,060 --> 01:08:40,300
Así, para este tipo de cousas que eu realmente quero formatar o texto que eu ía usar printf.

753
01:08:40,300 --> 01:08:44,689
Pero se non, eu ía usar só concatenação.

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

755
01:08:49,229 --> 01:09:00,170
Estamos só diferenciar os detalles entre comiñas simples e comiñas dobres.

756
01:09:00,170 --> 01:09:07,490
A maior diferenza é que comiñas simples, el será impreso literalmente.

757
01:09:07,490 --> 01:09:15,390
Non hai ningún tipo de datos char en PHP, ao contrario de C, de modo que este é equivalente a este.

758
01:09:15,390 --> 01:09:17,970
Son dúas cordas.

759
01:09:17,970 --> 01:09:29,180
E a cousa agradable sobre cordas aspas é que eu podería dicir 'Ola Mundo! " bla, bla, bla,

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

761
01:09:33,340 --> 01:09:38,260
O que acontece cando imprimir esta é que vai imprimir lo literalmente.

762
01:09:38,260 --> 01:09:40,680
Imos nos librar de todas as nosas cousas.

763
01:09:40,680 --> 01:09:44,700
Entón echo $ str1;

764
01:09:48,569 --> 01:09:56,570
É, literalmente, impreso todas estas cousas: signos de dólar,

765
01:09:56,570 --> 01:09:58,770
barra invertida n, cal pensas que sería newlines -

766
01:09:58,770 --> 01:10:01,500
todas estas cousas que imprime literalmente.

767
01:10:01,500 --> 01:10:05,650
O único que necesitas escapar son aspas

768
01:10:05,650 --> 01:10:09,470
porque se non, podería pensar que está pechando as comiñas simples.

769
01:10:09,470 --> 01:10:15,050
Comiñas, completamente diferentes.

770
01:10:20,300 --> 01:10:25,870
Xa vemos o destaque da sintaxe é cluing connosco para o que está a piques de ir terrible mal.

771
01:10:25,870 --> 01:10:36,190
php.unique. Indefinido variable: wooo porque esta é interpretada como unha variable chamada wooo.

772
01:10:36,190 --> 01:10:42,400
Comiñas dobres permiten que introducir variables -

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

774
01:10:52,730 --> 01:10:58,020
Entón echo "Hola, meu nome é $ nome";

775
01:10:58,020 --> 01:11:09,260
Ela recoñece esta como unha variable.

776
01:11:09,260 --> 01:11:21,210
Cando executo iso - e vou introducir unha nova liña - Ola, meu nome é Rob! e Ola mundo!

777
01:11:21,210 --> 01:11:24,910
Isto é porque nunca tirei a impresión de wooo anterior.

778
01:11:24,910 --> 01:11:30,020
Hai un paso máis que se pode facer.

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

780
01:11:39,250 --> 01:11:43,270
E se eu queira imprimir o primeiro índice de matriz?

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

782
01:11:45,150 --> 01:11:49,280
O realce de sintaxe é unha pista. O que é que isto vai facer?

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

784
01:11:54,510 --> 01:11:59,860
Ola, meu nome é 1! o que non é o que eu quería.

785
01:11:59,860 --> 01:12:05,050
O destaque da sintaxe mentiu para min.

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

787
01:12:18,450 --> 01:12:21,440
É así que eu tería que escribir.

788
01:12:26,350 --> 01:12:32,160
Comiñas simples inesperado (T_ENCAPSED bla, bla, bla, bla, bla).

789
01:12:32,160 --> 01:12:41,780
A idea é a de que non está recoñecendo isto como parte da matriz.

790
01:12:41,780 --> 01:12:46,620
Non está recoñecendo isto como matriz indexadas por unha carta.

791
01:12:46,620 --> 01:12:49,870
Quere facelo rodeado por chaves,

792
01:12:49,870 --> 01:12:54,730
e agora o que está neste chaveta serán interpoladas,

793
01:12:54,730 --> 01:13:00,340
que é a palabra que usamos para Magic inserción destas variables para os lugares certos.

794
01:13:00,340 --> 01:13:04,280
Agora facelo, php.unique, e Ola, meu nome é 1! como esperaba

795
01:13:04,280 --> 01:13:07,720
ou Ola, meu nome é Rob!

796
01:13:14,110 --> 01:13:23,130
Unha cousa que é unha especie de bo sobre aspas que -

797
01:13:23,130 --> 01:13:28,480
Hai algún custo para interpolación.

798
01:13:30,520 --> 01:13:35,100
Se usar comiñas dobres, o intérprete ten que pasar por riba esta secuencia,

799
01:13:35,100 --> 01:13:41,500
asegurarse de que, "Oh, aquí está unha variable. Agora eu teño ir buscar esa variable e inserir-lo aquí."

800
01:13:41,500 --> 01:13:48,930
Mesmo se non usar todas as variables,

801
01:13:48,930 --> 01:13:52,220
nada dentro destas aspas que ser interpolados,

802
01:13:52,220 --> 01:13:56,800
pero aínda vai ser máis lento porque necesita pasar por riba das aspas

803
01:13:56,800 --> 01:14:00,130
á procura de cousas que precisan ser interpolados.

804
01:14:00,130 --> 01:14:05,360
Entón citas individuais poden ser un pouco máis rápido se non ten que ser interpolados,

805
01:14:05,360 --> 01:14:15,650
e eu aínda tenden a usar comiñas simples para "Ola, meu nome é '. $ Array ['a'] de calquera maneira.

806
01:14:15,650 --> 01:14:20,430
Isto vai ser equivalente ao que tiñamos antes.

807
01:14:24,840 --> 01:14:28,440
Pero é unha cuestión de preferencia.

808
01:14:28,440 --> 01:14:34,750
Se está usando PHP, probablemente non lle importa a diferenza de velocidade.

809
01:14:34,750 --> 01:14:39,480
Non é o suficiente para razoar los para comezar.

810
01:14:39,480 --> 01:14:43,030
>> Todas as preguntas finais?

811
01:14:47,430 --> 01:14:51,710
>> En realidade, nin sequera pasar por todo iso, pero este material era aburrido.

812
01:14:51,710 --> 01:14:59,080
A última cousa que é unha especie de bo no PHP é cando está lidando con HTML,

813
01:14:59,080 --> 01:15:06,450
vai usalo un pouco, entón a sintaxe bo atallo para a impresión dunha variable.

814
01:15:32,400 --> 01:15:36,730
Sen poñer PHP aquí, iso é chamado de etiquetas curtas.

815
01:15:36,730 --> 01:15:44,330
Oficialmente a partir do PHP 5.4, que é depreciada.

816
01:15:44,330 --> 01:15:48,640
Recoméndase colocar php.

817
01:15:48,640 --> 01:15:55,770
Este aínda é soportado, etiquetas para curtas con <? = Aínda están perfectamente ben.

818
01:15:55,770 --> 01:16:02,480
É apoiado por defecto, entón podes usalos como queiras, e son moi cómodo.

819
01:16:02,480 --> 01:16:05,700
>> Algunha pregunta?

820
01:16:07,780 --> 01:16:09,270
Todo ben.

821
01:16:10,840 --> 01:16:13,800
>> Sexa elegante, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Risas]

823
01:16:18,620 --> 01:16:22,660
Tchau. [Risas]

824
01:16:24,350 --> 01:16:28,470
[Aplausos] [risas]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]