1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Seção 8 - Mais Confortável]

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 secção semanas vão ser muito curto,

5
00:00:14,160 --> 00:00:19,070
então eu só vou continuar a falar, vocês vão continuar a fazer perguntas,

6
00:00:19,070 --> 00:00:22,720
e vamos tentar preencher o tempo, tanto quanto possível.

7
00:00:22,720 --> 00:00:31,950
Muitas pessoas pensam que este pset não é necessariamente difícil, mas é muito longo.

8
00:00:31,950 --> 00:00:37,070
A especificação pset si leva uma hora para ler.

9
00:00:40,530 --> 00:00:45,730
Nós damos-lhe um monte de SQL que você poderia possivelmente necessidade de usar.

10
00:00:45,730 --> 00:00:50,520
Nós levá-lo através de um monte de que, por isso não deve ser muito ruim.

11
00:00:50,520 --> 00:00:54,560
Alguém já começou ou terminou?

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

13
00:00:59,710 --> 00:01:05,400
Normalmente há um JavaScript um depois, mas as coisas mudam calendário

14
00:01:05,400 --> 00:01:09,560
torna tudo uma semana mais curta, e não temos mais um pset JavaScript.

15
00:01:09,560 --> 00:01:12,310
Eu não sei como isso afeta se o JavaScript está indo para aparecer no exame

16
00:01:12,310 --> 00:01:15,510
ou Questionário 1.

17
00:01:15,510 --> 00:01:22,260
Imagino que será algo como que você precisa saber coisas de alto nível sobre JavaScript,

18
00:01:22,260 --> 00:01:26,460
mas duvido que tinha acabado de dar-lhe diretamente o código JavaScript

19
00:01:26,460 --> 00:01:28,720
já que não tinha um pset nele.

20
00:01:28,720 --> 00:01:33,000
Mas isso vai ser o material para análise teste na próxima semana.

21
00:01:33,000 --> 00:01:36,320
>> Seção de perguntas.

22
00:01:36,320 --> 00:01:43,870
Uma grande quantidade deste material é um pouco mal formulada, mas vamos discutir o porquê.

23
00:01:43,870 --> 00:01:50,220
Ao contrário de C, PHP é uma "dinamicamente tipada" idioma. O que isso significa, você pergunta?

24
00:01:50,220 --> 00:01:53,830
Bem, diga adeus a todos aqueles float, char, int e outras palavras-chave que você precisa para usar

25
00:01:53,830 --> 00:01:56,190
ao declarar variáveis ​​e funções em C.

26
00:01:56,190 --> 00:02:00,420
No PHP, tipo de uma variável é determinado pelo valor que está actualmente detém.

27
00:02:00,420 --> 00:02:04,990
Assim, antes de digitar esse código em um arquivo chamado dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP é dinamicamente digitado. Isso é verdade.

29
00:02:12,670 --> 00:02:17,590
Eu discordo com o fato de que isso significa que estamos dizendo adeus a char, int, float,

30
00:02:17,590 --> 00:02:20,620
e outras palavras-chave.

31
00:02:20,620 --> 00:02:25,510
A diferença exata entre tipagem dinâmica e alternativa,

32
00:02:25,510 --> 00:02:32,010
que é digitado estaticamente, é que tipagem dinâmica, toda a sua verificação de tipo e material

33
00:02:32,010 --> 00:02:37,350
acontece em tempo de execução, enquanto que tipagem estática acontece em tempo de compilação.

34
00:02:37,350 --> 00:02:43,030
A palavra estática em geral parece significar coisas tempo de compilação.

35
00:02:43,030 --> 00:02:48,170
Eu acho que existem outros usos para ele, mas em C quando você declara uma variável estática,

36
00:02:48,170 --> 00:02:52,650
seu armazenamento é alocado em tempo de compilação.

37
00:02:52,650 --> 00:02:59,260
Aqui, tipagem dinâmica significa apenas que -

38
00:02:59,260 --> 00:03:04,350
Em C, se você tentar adicionar uma string e um inteiro, quando você compilar,

39
00:03:04,350 --> 00:03:11,000
ele vai reclamar, porque vai dizer que você não pode adicionar um int e um ponteiro.

40
00:03:11,000 --> 00:03:14,710
Não é apenas uma operação válida.

41
00:03:14,710 --> 00:03:21,170
Essa é outra coisa que nós vamos chegar a um segundo.

42
00:03:21,170 --> 00:03:24,860
Mas esse tipo de verificação, o fato de que ele se queixa em tempo de compilação,

43
00:03:24,860 --> 00:03:29,220
é a verificação de tipo estático.

44
00:03:29,220 --> 00:03:35,220
Há línguas em que você não precisa dizer float, char, int, e todas essas coisas,

45
00:03:35,220 --> 00:03:40,940
mas a linguagem pode dizer a partir do contexto da coisa que tipo que é suposto ser,

46
00:03:40,940 --> 00:03:43,980
mas ainda tipagem estática.

47
00:03:43,980 --> 00:03:49,000
Então, se você tomar 51, OCaml, nunca você precisa usar qualquer um desses tipos,

48
00:03:49,000 --> 00:03:58,700
mas ainda vai a tempo de compilação dizer que você não pode fazer isso porque você está misturando um int e uma corda.

49
00:03:58,700 --> 00:04:05,650
Dinamicamente digitado apenas significa que em algum momento durante o tempo de execução que você está indo para obter uma reclamação.

50
00:04:05,650 --> 00:04:13,430
Se você também usado Java antes de, em geral, quase todas as línguas do tipo C

51
00:04:13,430 --> 00:04:20,070
vai ser digitado estaticamente, de modo C, C + +, Java, todos estes são geralmente digitado estaticamente.

52
00:04:20,070 --> 00:04:22,910
Em Java, quando você compilar algo e você está dizendo

53
00:04:22,910 --> 00:04:26,670
string s equivale a algo novo que não é uma string,

54
00:04:26,670 --> 00:04:28,950
que vai reclamar porque esses tipos simplesmente não combinam.

55
00:04:28,950 --> 00:04:31,180
Que vai reclamar em tempo de compilação.

56
00:04:31,180 --> 00:04:36,750
Mas ele também tem algum tempo dinâmica coisas como se você tentar lançar alguma coisa

57
00:04:36,750 --> 00:04:40,500
para um tipo que é mais específico do que o seu tipo de corrente,

58
00:04:40,500 --> 00:04:45,610
não há nada que ele pode fazer em tempo de compilação para verificar se que o elenco está indo para ter sucesso.

59
00:04:45,610 --> 00:04:51,130
Java também tem algum tipo dinâmico verificar que, logo que se chega a esta linha de código

60
00:04:51,130 --> 00:04:54,130
quando ele é, na verdade, a execução, ele vai fazer o elenco,

61
00:04:54,130 --> 00:04:56,260
verificar se aquele elenco era válido, em primeiro lugar,

62
00:04:56,260 --> 00:04:59,890
e se não estiver, então ele vai reclamar que você tem um tipo inválido.

63
00:04:59,890 --> 00:05:03,200
Tipo dinâmico verificação.

64
00:05:03,200 --> 00:05:07,010
Digite isso em um arquivo chamado dynamic.php.

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

66
00:05:14,580 --> 00:05:17,190
Eu vou descompactar que a formatação.

67
00:05:18,750 --> 00:05:21,880
Nós temos uma variável, defina-o inteiro 7,

68
00:05:21,880 --> 00:05:27,930
então vamos imprimi-lo e s% -

69
00:05:27,930 --> 00:05:32,830
Ah, estamos imprimindo o tipo dele, de modo gettype vai retornar o tipo da variável.

70
00:05:32,830 --> 00:05:35,720
Estamos apenas a impressão do tipo de uma e outra vez.

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

72
00:05:39,440 --> 00:05:45,920
Vamos ver o que ele muda de inteiro para string para Boolean como nós passamos.

73
00:05:45,920 --> 00:05:54,590
Em C não há nenhum tipo de dados Boolean, não há tipo de dados.

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

75
00:06:00,500 --> 00:06:05,690
No PHP estes tipos não existem, e isso é uma das grandes vantagens do PHP sobre C -

76
00:06:05,690 --> 00:06:13,290
seqüência de operações que são infinitamente mais fácil do que em PHP C. Eles só trabalhar.

77
00:06:13,290 --> 00:06:18,290
>> Assim, voltamos aqui.

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

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

80
00:06:26,710 --> 00:06:30,250
Se você tiver qualquer erro no arquivo, o intérprete irá dizer-lhe!

81
00:06:30,250 --> 00:06:39,110
O intérprete, esta é outra grande diferença entre PHP e C.

82
00:06:39,110 --> 00:06:48,200
Em C você tem que compilar algo em seguida, executar o arquivo compilado.

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

84
00:06:50,490 --> 00:06:57,200
Assim, o interpretador do PHP é, basicamente, apenas lendo esta linha por linha.

85
00:06:57,200 --> 00:07:02,900
Ela atinge var = 7, em seguida, ela atinge printf então ela atinge var então ela atinge printf e assim por diante.

86
00:07:02,900 --> 00:07:10,910
Há um pouco de compilar que faz, e ele armazena em cache os resultados

87
00:07:10,910 --> 00:07:15,510
por isso, se você executar o script mais tarde você pode fazer alguns,

88
00:07:15,510 --> 00:07:19,280
mas basicamente é uma linha por linha tipo de coisa.

89
00:07:19,280 --> 00:07:25,280
Isso significa que um monte de otimizações que nós começamos em C,

90
00:07:25,280 --> 00:07:31,920
como a compilação, é apenas geralmente o compilador pode fazer um monte de truques para você.

91
00:07:31,920 --> 00:07:36,110
Ele pode tirar as variáveis ​​utilizadas, pode fazer todos esses tipos de coisas,

92
00:07:36,110 --> 00:07:38,660
ele pode fazer recursão de cauda.

93
00:07:38,660 --> 00:07:42,550
No PHP você não está indo para obter essa vantagem

94
00:07:42,550 --> 00:07:45,690
porque só vai começar a executar linha por linha por linha,

95
00:07:45,690 --> 00:07:49,950
e ele realmente não se reconhecer essas coisas tão facilmente

96
00:07:49,950 --> 00:07:54,440
já que não é um passo de compilação de grande sobre a coisa e, em seguida, a execução;

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

98
00:08:00,730 --> 00:08:02,750
Então esse é o intérprete.

99
00:08:02,750 --> 00:08:06,840
>> Voltar para a nossa tipagem dinâmica: muito legal, né?

100
00:08:06,840 --> 00:08:08,640
Você definitivamente não poderia fazer isso em C!

101
00:08:08,640 --> 00:08:11,860
Agora, veja se você consegue descobrir o tipo de cada um dos seguintes valores.

102
00:08:11,860 --> 00:08:14,760
Veja este para referência.

103
00:08:14,760 --> 00:08:19,420
Então, 3,50. Que tipo você acha que vai ser?

104
00:08:24,480 --> 00:08:26,370
Aqui estão os tipos que temos.

105
00:08:26,370 --> 00:08:30,430
Temos bools, inteiros, pontos flutuantes, strings, arrays, objetos,

106
00:08:30,430 --> 00:08:38,370
e recursos, que é uma espécie de vaga.

107
00:08:38,370 --> 00:08:41,010
Eu acho que há, na verdade, um exemplo aqui.

108
00:08:41,010 --> 00:08:43,740
Então há NULL. NULL é um tipo especial.

109
00:08:43,740 --> 00:08:47,140
Ao contrário de C onde NULL é apenas um ponteiro com o endereço 0,

110
00:08:47,140 --> 00:08:54,930
em PHP, NULL é o seu próprio tipo, onde a única coisa válida de que tipo é NULL.

111
00:08:57,560 --> 00:09:00,670
Isso é muito mais útil para verificação de erros.

112
00:09:00,670 --> 00:09:04,310
Em C, onde tivemos esta questão onde se você retornar NULL,

113
00:09:04,310 --> 00:09:08,660
isso significa que você está retornando um ponteiro NULL ou usar NULL para indicar erro

114
00:09:08,660 --> 00:09:12,380
ou toda essa confusão que teve em um ponto.

115
00:09:12,380 --> 00:09:18,440
Aqui, retornando NULL geralmente significa erro.

116
00:09:20,860 --> 00:09:27,300
Um monte de coisas também retornar false para erro.

117
00:09:27,300 --> 00:09:33,140
Mas o ponto é o tipo NULL, a única coisa do tipo NULL é NULL.

118
00:09:33,140 --> 00:09:40,090
Então callback é como você pode definir algumas funções anônimas.

119
00:09:40,090 --> 00:09:46,420
Você não tem que dar a função de um nome, mas você não terá que lidar com isso aqui.

120
00:09:46,420 --> 00:09:53,940
Olhando para os tipos que eles esperam que a gente sabe,

121
00:09:53,940 --> 00:09:59,000
o que você acha do tipo de 3,50 é? >> [Aluno] Float.

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

123
00:10:00,370 --> 00:10:06,290
Então aqui, o que você acha do tipo de que é isso? >> [Aluno] Array.

124
00:10:06,290 --> 00:10:09,890
Sim. A primeira foi a bóia, a segunda é uma matriz.

125
00:10:09,890 --> 00:10:14,500
Observe que essa matriz não é como uma matriz C

126
00:10:14,500 --> 00:10:19,610
onde você tem índice 0 tem algum valor, índice 1 tem algum valor.

127
00:10:19,610 --> 00:10:26,320
Aqui, os índices são a, b, e c, e os valores são 1, 2, e 3.

128
00:10:26,320 --> 00:10:33,980
No PHP, não há diferença entre uma matriz associativa e apenas uma matriz comum

129
00:10:33,980 --> 00:10:36,740
como seria de pensar nisso em C.

130
00:10:36,740 --> 00:10:43,040
Não é apenas isso, e debaixo do capô uma matriz regular é apenas uma matriz associativa

131
00:10:43,040 --> 00:10:50,000
onde 0 mapas para algum valor da mesma maneira uma mapas para algum valor.

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

133
00:11:00,410 --> 00:11:07,930
já que em C, quando você estiver usando uma matriz que você sabe que o acesso a um membro é tempo constante.

134
00:11:07,930 --> 00:11:11,860
No PHP acessando um membro é quem sabe quanto tempo?

135
00:11:11,860 --> 00:11:18,970
Provavelmente é constante se hashes corretamente.

136
00:11:18,970 --> 00:11:21,620
Quem sabe o que ele está realmente fazendo debaixo do capô?

137
00:11:21,620 --> 00:11:25,600
Você realmente precisa de olhar para a implementação para ver como ele vai lidar com isso.

138
00:11:25,600 --> 00:11:28,550
Então fopen.

139
00:11:28,550 --> 00:11:36,420
Eu acho que aqui vamos apenas PHP fopen manual para olhar para o tipo de retorno.

140
00:11:36,420 --> 00:11:41,260
Vemos aqui que você pode olhar para cima praticamente qualquer função no manual do PHP

141
00:11:41,260 --> 00:11:47,540
e este é o tipo de homem a página do 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 isso que eu olhei para cima, porque nós realmente não definir recursos.

144
00:11:56,050 --> 00:12:04,110
A idéia de recurso, em C você tem um tipo de arquivo * ou o que quer;

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

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

147
00:12:10,360 --> 00:12:20,710
É geralmente externo, por isso é um recurso que você pode puxar coisas e atirar coisas para.

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

149
00:12:26,520 --> 00:12:30,650
Sim. Então a única coisa que é NULL é NULL.

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

151
00:12:35,490 --> 00:12:41,170
>> Uma característica do sistema PHP tipo (para melhor ou para pior) é a sua capacidade de fazer malabarismos tipos.

152
00:12:41,170 --> 00:12:44,390
Quando você escrever uma linha de código PHP que combina valores de diferentes tipos,

153
00:12:44,390 --> 00:12:46,670
PHP vai tentar fazer a coisa sensata.

154
00:12:46,670 --> 00:12:48,920
Experimente cada uma das seguintes linhas de código PHP. O que está impresso?

155
00:12:48,920 --> 00:12:51,000
É o que você esperava? Por que ou por que não?

156
00:12:51,000 --> 00:12:58,600
Este fato sobre o PHP é o que faz o que chamamos de fracamente tipada.

157
00:12:58,600 --> 00:13:04,610
Fracamente digitado e rigidez,

158
00:13:04,610 --> 00:13:06,840
existem usos diferentes para esses termos,

159
00:13:06,840 --> 00:13:12,020
mas a maioria das pessoas usam fracamente digitado e rigidez para dizer esse tipo de coisa

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

161
00:13:15,920 --> 00:13:18,290
Em C que não iria funcionar.

162
00:13:18,290 --> 00:13:22,490
Você pode imaginar isso não funciona.

163
00:13:22,490 --> 00:13:29,200
Um monte de gente misturar tipagem dinâmica e tipagem fraca e tipagem estática e tipagem forte.

164
00:13:29,200 --> 00:13:34,050
Python é outro exemplo de uma linguagem que é dinamicamente digitado.

165
00:13:34,050 --> 00:13:41,770
Você pode jogar em torno de tipos de variáveis ​​e que vai determinar em tempo de execução

166
00:13:41,770 --> 00:13:44,680
quaisquer verificações de erro.

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

168
00:13:50,740 --> 00:13:55,920
e isso vai falhar porque ele diz que você não pode adicionar uma string e um inteiro.

169
00:13:55,920 --> 00:14:00,860
No PHP, que é tão tipagem dinâmica, isso não vai falhar.

170
00:14:00,860 --> 00:14:04,220
Tipagem fraca tem a ver com o fato de que ele faz coisas com tipos

171
00:14:04,220 --> 00:14:07,800
que realmente não faz sentido necessariamente.

172
00:14:07,800 --> 00:14:17,420
Então ("1" + 2), eu posso imaginar que ser o de 12 cordas, eu posso imaginar que seja a seqüência de três,

173
00:14:17,420 --> 00:14:20,710
Eu posso imaginar que seja o 3 inteiro.

174
00:14:20,710 --> 00:14:24,530
Não é necessariamente bem definido, e nós provavelmente vamos ver aqui

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

176
00:14:29,140 --> 00:14:32,320
de impressão (1 + "2").

177
00:14:32,320 --> 00:14:39,700
E isso tende a ser, na minha opinião, para pior.

178
00:14:39,700 --> 00:14:44,240
Aqui podemos experimentar estes.

179
00:14:44,240 --> 00:14:48,740
Outro truque pouco sobre PHP é que você não precisa realmente gravar o arquivo.

180
00:14:48,740 --> 00:14:52,790
Ele tem de executar este modo de comando.

181
00:14:52,790 --> 00:14:57,710
Então php-r, então podemos jogar no comando aqui:

182
00:14:57,710 --> 00:15:06,610
"Print ('1 '+ 2);" e eu vou lançar uma nova linha.

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

184
00:15:31,100 --> 00:15:35,330
Parece que ele imprime 3 e é o 3 inteiro.

185
00:15:35,330 --> 00:15:38,420
Então, agora vamos tentar o contrário:

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

187
00:15:45,560 --> 00:15:50,490
Nós temos 3, e é isso também vai ser inteiro 3? Sinceramente, não tenho idéia.

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

189
00:15:54,030 --> 00:15:59,550
Nunca há qualquer chance de ele ser o 12 cordas ou qualquer coisa assim

190
00:15:59,550 --> 00:16:08,080
porque o PHP, ao contrário de JavaScript e Java também,

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

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

193
00:16:14,930 --> 00:16:22,950
Assim, a impressão (1 '2 '.); Vai dar-nos 12.

194
00:16:25,790 --> 00:16:32,420
Isso tende a levar a uma confusão onde as pessoas tentam fazer algo como str + =

195
00:16:32,420 --> 00:16:37,840
alguma outra coisa que eles querem adicionar para o fim de sua corda, e que vai falhar.

196
00:16:37,840 --> 00:16:40,770
Você precisa fazer str. =

197
00:16:42,000 --> 00:16:46,240
Então não se esqueça de concatenação em PHP é um ponto.

198
00:16:46,240 --> 00:16:52,100
Outras coisas para tentar: print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Eu já lhe disse que não há esperança de que isto resulte na CS50

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

201
00:17:06,119 --> 00:17:08,440
O que você acha que isso vai acabar sendo?

202
00:17:10,359 --> 00:17:13,460
Eu sinceramente não tenho absolutamente nenhuma idéia.

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

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

205
00:17:21,490 --> 00:17:29,640
Ele vê a primeira corda, ele tenta ler um número inteiro de que ou um número a partir dele.

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

207
00:17:31,710 --> 00:17:35,190
"Isso não faz sentido como um número inteiro, então eu só vou pensar em 123."

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

209
00:17:38,580 --> 00:17:40,740
E aqui começa a ler isso como um número inteiro.

210
00:17:40,740 --> 00:17:45,690
Ele não vê nada, por isso só trata como 0. Então 0 + 50 vai ser 50.

211
00:17:45,690 --> 00:17:51,600
Isto que eu estou supondo que vai fazer algo semelhante.

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

213
00:17:54,310 --> 00:17:57,580
Sim, porque vai levar a primeira -

214
00:18:12,880 --> 00:18:15,730
Então, 99.

215
00:18:15,730 --> 00:18:21,970
Aqui (10/7), se este fosse C, o que teria que voltar?

216
00:18:23,700 --> 00:18:29,630
[Estudante] 1. >> Sim, seria um porque 10/7 é dividir 2 números inteiros.

217
00:18:29,630 --> 00:18:32,910
Um inteiro dividido por um número inteiro vai retornar um inteiro.

218
00:18:32,910 --> 00:18:37,750
Ele não pode retornar um qualquer ponto que seria, por isso só vai retornar 1.

219
00:18:37,750 --> 00:18:46,120
Aqui impressão (10/7), que vai realmente interpretar isso.

220
00:18:46,120 --> 00:18:53,760
E isso significa que se você realmente quer fazer arredondamento inteiro e coisas assim,

221
00:18:53,760 --> 00:18:59,950
você precisa fazer impressão (piso (10/7));

222
00:18:59,950 --> 00:19:08,460
Em C é provavelmente estranho que você pode confiar em truncamento inteiro regularmente,

223
00:19:08,460 --> 00:19:12,260
mas em PHP você não pode porque ele será automaticamente transformá-lo em um carro alegórico.

224
00:19:13,430 --> 00:19:17,610
E depois (7 + true), o que você acha que vai ser?

225
00:19:18,550 --> 00:19:23,640
Eu estou supondo que 8 se ele vai interpretar como uma verdadeira.

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

227
00:19:25,740 --> 00:19:31,710
>> Então, qualquer coisa que fizemos nos últimos 10 minutos que você nunca deve fazer absolutamente.

228
00:19:31,710 --> 00:19:39,870
Você vai ver o código que faz isso.

229
00:19:39,870 --> 00:19:42,700
Ela não tem de ser tão simples como este.

230
00:19:42,700 --> 00:19:47,240
Você pode ter duas variáveis, e uma variável passa a ser uma string

231
00:19:47,240 --> 00:19:51,310
e outra variável passa a ser um int, e depois de adicionar essas variáveis ​​juntas.

232
00:19:51,310 --> 00:20:00,120
Desde o PHP é tipada dinamicamente e não vai fazer qualquer tipo de verificação para você

233
00:20:00,120 --> 00:20:03,640
E já que é fracamente digitados e, uma vez que só irá automaticamente jogar essas coisas juntos

234
00:20:03,640 --> 00:20:11,490
e tudo vai funcionar, é difícil até mesmo saber que esta variável deve ser uma seqüência de agora,

235
00:20:11,490 --> 00:20:14,930
por isso não deve adicionar a essa variável, que é um inteiro.

236
00:20:18,780 --> 00:20:24,560
A melhor prática é se uma variável é uma string, mantê-lo como uma string para sempre.

237
00:20:24,560 --> 00:20:26,980
Se a variável é um int, mantê-lo como um int para sempre.

238
00:20:26,980 --> 00:20:30,770
Se você quer lidar com números inteiros e strings,

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

240
00:20:36,970 --> 00:20:42,520
Intval. Eu faço isso o tempo todo. PHP e JavaScript eu misturo tudo.

241
00:20:42,520 --> 00:20:47,600
Então intval vai retornar o valor inteiro de uma variável.

242
00:20:47,600 --> 00:20:56,550
Se passar em "print (intval ('123 ')), você começa 123.

243
00:21:06,820 --> 00:21:15,850
Intval si só não vai fazer o cheque para nós que é exclusivamente um inteiro.

244
00:21:15,850 --> 00:21:20,460
O manual do PHP, existem apenas funções tantas disponível,

245
00:21:20,460 --> 00:21:26,560
então aqui eu acho que o que eu usaria é is_numeric primeiro.

246
00:21:26,560 --> 00:21:32,590
Eu estou supondo que retornou falso.

247
00:21:32,590 --> 00:21:35,780
Isso é outra coisa que temos que passar por cima é. ===

248
00:21:37,850 --> 00:21:44,020
Então is_numeric ('123df '), você não pensaria que, como is_numeric.

249
00:21:44,020 --> 00:21:46,720
Em C, você teria que iterar sobre todos os personagens

250
00:21:46,720 --> 00:21:50,410
e verificar para ver se cada personagem é o dígito ou o que quer.

251
00:21:50,410 --> 00:21:53,850
Aqui is_numeric vai fazer isso por nós,

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

253
00:21:56,520 --> 00:22:02,120
Então, quando eu impressa, é impresso nada, então aqui estou comparando-o a ver,

254
00:22:02,120 --> 00:22:05,490
se acontecer de você ser falsa? E agora ele está imprimindo um.

255
00:22:05,490 --> 00:22:10,060
Aparentemente, ele imprime um como verdadeiro em vez de imprimir verdadeiro como verdadeiro.

256
00:22:10,060 --> 00:22:15,790
Gostaria de saber se posso fazer print_r. Não, ele ainda faz um.

257
00:22:15,790 --> 00:22:26,760
>> Voltando ao ===, == ainda existe,

258
00:22:26,760 --> 00:22:32,260
e se você falar com Tommy ele vai dizer == é perfeitamente bem.

259
00:22:32,260 --> 00:22:37,700
Eu vou dizer que == é terrível e você nunca deve usar. ==

260
00:22:37,700 --> 00:22:44,870
A diferença é que as coisas == compara

261
00:22:44,870 --> 00:22:48,450
onde pode ser verdadeiro mesmo se eles não são do mesmo tipo,

262
00:22:48,450 --> 00:22:53,810
Considerando === compara coisas e primeiro, verifica são eles mesmo tipo?

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

264
00:22:58,010 --> 00:23:08,890
Você começa coisas estranhas como 10 é igual a - vamos ver o que diz.

265
00:23:08,890 --> 00:23:15,570
Então ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
Isso retorna verdadeiro.

267
00:23:17,980 --> 00:23:21,420
Alguém tem algum palpite porque este retorna verdade?

268
00:23:25,180 --> 00:23:27,120
Não é apenas sobre isso. Talvez esta seja uma dica.

269
00:23:27,120 --> 00:23:33,170
Mas se eu mudar isso para um f - Droga! Eu continuo usando aspas duplas.

270
00:23:33,170 --> 00:23:38,780
A razão das aspas estão gritando comigo é porque eu coloquei isso em aspas.

271
00:23:38,780 --> 00:23:43,850
Então, eu poderia escapar as aspas aqui, mas aspas simples torná-lo mais fácil.

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

273
00:23:49,120 --> 00:23:56,330
[Estudante] É hexa? >> Não é hexa, mas está perto que é como -

274
00:23:56,330 --> 00:24:01,060
Notação, 1e1 científica.

275
00:24:01,060 --> 00:24:07,950
Ele reconhece como 1e1 1 * 10 ^ 1, ou o que seja.

276
00:24:07,950 --> 00:24:11,510
Esses são números inteiros iguais.

277
00:24:11,510 --> 00:24:15,930
Se fizermos === então vai ser falsa.

278
00:24:15,930 --> 00:24:28,490
Eu realmente não tenho idéia se nós fazemos o que dizer == (10 e '10abc ');? Tudo bem. Então, isso é verdade.

279
00:24:28,490 --> 00:24:35,940
Assim como quando você fez (10 + '10abc '), e que seria 20,

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

281
00:24:38,800 --> 00:24:45,350
Pior ainda são coisas como (falsa == NULL); é verdade

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

283
00:24:52,210 --> 00:25:00,970
Há casos estranhos de - Isso é um daqueles casos estranhos.

284
00:25:00,970 --> 00:25:08,110
Observe 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ão == não é de forma transitiva.

288
00:25:19,090 --> 00:25:26,830
um pode ser igual a um e b pode ser igual a c,

289
00:25:26,830 --> 00:25:29,340
mas b pode não ser igual a c.

290
00:25:29,340 --> 00:25:35,580
Isso é uma abominação para mim, e você deve sempre usar. ===

291
00:25:35,580 --> 00:25:38,590
[Aluno] Podemos fazer! == Também? >> [Bowden] Sim.

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

293
00:25:44,600 --> 00:25:48,230
Isto é, na verdade, trouxe-se na especificação pset

294
00:25:48,230 --> 00:25:52,000
onde um monte de retorno funções -

295
00:25:52,000 --> 00:25:53,890
O manual do PHP é bom sobre isso.

296
00:25:53,890 --> 00:25:59,140
Ela coloca em uma grande caixa vermelha "Isso irá retornar falso se não há um erro."

297
00:25:59,140 --> 00:26:03,940
Mas retornando 0 é uma coisa perfeitamente razoável para voltar.

298
00:26:03,940 --> 00:26:08,250
Pense em qualquer função que é esperado para retornar um inteiro.

299
00:26:11,250 --> 00:26:17,880
Vamos dizer que esta função deve contar o número de linhas em um arquivo ou algo assim.

300
00:26:17,880 --> 00:26:23,490
Em circunstâncias normais, você passa esta função um arquivo

301
00:26:23,490 --> 00:26:27,120
e que vai retornar um inteiro que representa o número de linhas.

302
00:26:27,120 --> 00:26:30,820
Então, 0 é um número perfeitamente razoável se o arquivo é apenas vazio.

303
00:26:30,820 --> 00:26:36,810
Mas o que se você passar um arquivo inválido ea função acontece a retornar falso

304
00:26:36,810 --> 00:26:38,860
se você passar um arquivo inválido?

305
00:26:38,860 --> 00:26:46,500
Se você acabou de fazer == você não está diferenciando o caso entre arquivo inválido e arquivo vazio.

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

307
00:26:55,690 --> 00:26:58,000
Isso é tudo isso.

308
00:26:58,000 --> 00:27:01,660
>> No PHP, o tipo de matriz é diferente do que você está acostumado em C.

309
00:27:01,660 --> 00:27:06,650
Na verdade, você já deve ter notado esta acima de quando você viu que este é do tipo Array.

310
00:27:06,650 --> 00:27:15,640
A sintaxe suporte é novo no PHP 5.4, que é a mais nova versão do PHP.

311
00:27:15,640 --> 00:27:36,960
Antes isso, você sempre tinha que escrever array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Esse foi o construtor para uma matriz.

313
00:27:41,160 --> 00:27:45,950
Agora PHP finalmente chegou perto para a sintaxe agradável de apenas colchetes,

314
00:27:45,950 --> 00:27:50,900
que é apenas muito melhor do array.

315
00:27:50,900 --> 00:27:54,480
Mas, considerando o PHP 5.4 é a versão mais recente,

316
00:27:54,480 --> 00:27:59,090
você pode encontrar lugares que não têm sequer PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Durante o verão, corri para este problema em PHP 5.3 era o que tínhamos no aparelho,

318
00:28:08,220 --> 00:28:14,480
mas o servidor que implantado todo o livro o nosso grau e enviar e todas as coisas que a

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

320
00:28:16,750 --> 00:28:23,060
Não sabendo disso, desenvolvemos em 5,3, empurrou para 5,4,

321
00:28:23,060 --> 00:28:25,660
e agora, de repente nenhum de nosso código funciona

322
00:28:25,660 --> 00:28:28,680
porque não aconteceu ter sido mudanças entre 5,3 e 5,4

323
00:28:28,680 --> 00:28:31,030
que não são compatíveis,

324
00:28:31,030 --> 00:28:35,770
e nós temos que ir e corrigir todas as nossas coisas que não funcionam para PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
Para esta classe, uma vez que o aparelho tem PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
é perfeitamente possível usar colchetes.

327
00:28:47,240 --> 00:28:50,440
Mas se você está olhando para as coisas ao redor da Internet,

328
00:28:50,440 --> 00:28:54,880
se você está procurando algum tipo de material matriz, o mais provável é que você vai ver

329
00:28:54,880 --> 00:29:02,020
o feitiço fora sintaxe construtor de matriz desde que existe desde o PHP nasceu

330
00:29:02,020 --> 00:29:07,340
e sintaxe de colchetes tem sido em torno dos últimos dois meses

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

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

333
00:29:12,710 --> 00:29:30,610
Assim como em C como se fosse o índice por colchetes como $ array [0], array $ [1], array $ [2],

334
00:29:30,610 --> 00:29:36,320
você índice da mesma forma se acontecer de você ter 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 isso seria errado?

337
00:29:52,490 --> 00:29:59,870
Ele provavelmente irá gerar um aviso, mas ainda funciona. PHP tende a fazer isso.

338
00:29:59,870 --> 00:30:04,890
Ela tende a apenas: "Eu estou indo para avisá-lo sobre isso, mas eu só vou continuar

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

340
00:30:07,550 --> 00:30:11,500
Ele provavelmente irá traduzir isso para uma string,

341
00:30:11,500 --> 00:30:15,000
, mas é possível que, em algum ponto no passado alguém disse

342
00:30:15,000 --> 00:30:20,180
definir b ser 'OLÁ MUNDO ".

343
00:30:20,180 --> 00:30:28,740
Então, agora b poderia ser uma constante de matriz e US $ [b] vai ser realmente fazendo "OLÁ MUNDO".

344
00:30:28,740 --> 00:30:32,380
Eu acho que neste momento, ou pelo menos nossas configurações PHP,

345
00:30:32,380 --> 00:30:37,870
se você tentar índice em uma matriz e essa chave não existe, ele irá falhar.

346
00:30:37,870 --> 00:30:40,150
Eu não acho que isso só vai te avisar.

347
00:30:40,150 --> 00:30:44,560
Ou pelo menos, você pode configurá-lo para que ele não apenas adverti-lo, apenas em linha reta até falhar.

348
00:30:44,560 --> 00:30:49,290
>> A maneira como você verificar para ver se há realmente um tal índice é isset.

349
00:30:49,290 --> 00:30:54,690
Então isset ($ array ['OLÁ MUNDO']) retornará falso.

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

351
00:31:06,830 --> 00:31:09,880
Você pode misturar essas sintaxes.

352
00:31:15,060 --> 00:31:22,440
Tenho certeza de que essa matriz acabaria sendo é - Nós podemos testá-lo.

353
00:31:43,290 --> 00:31:45,700
Oh, eu preciso de PHPWord.

354
00:31:53,960 --> 00:32:00,260
Este é misturar a sintaxe onde você especificar o que é a chave

355
00:32:00,260 --> 00:32:03,330
e você não especificar o que está a chave.

356
00:32:03,330 --> 00:32:05,520
Então 3 aqui é um valor.

357
00:32:05,520 --> 00:32:08,080
Você não disse explicitamente que a sua chave é que vai ser.

358
00:32:08,080 --> 00:32:11,670
O que você acha de sua chave vai ser?

359
00:32:11,670 --> 00:32:21,410
[Estudante] 0. >> Eu estou supondo 0 só porque é o primeiro que não especificou.

360
00:32:21,410 --> 00:32:23,500
Nós podemos realmente fazer um par desses casos.

361
00:32:23,500 --> 00:32:28,030
Então print_r é imprimir recursiva. Ele irá imprimir toda a matriz.

362
00:32:28,030 --> 00:32:32,700
Seria imprimir subarrays da matriz, se houvesse algum.

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

364
00:32:36,630 --> 00:32:38,810
Ele se parece com ele deu 0.

365
00:32:38,810 --> 00:32:43,530
Na verdade, há algo a ter em mente aqui, mas vamos voltar a ele em um segundo.

366
00:32:43,530 --> 00:32:45,850
Mas o que se acontecer de eu fazer este índice 1?

367
00:32:45,850 --> 00:32:51,170
PHP não faz diferença entre os índices de cordas e índices inteiros,

368
00:32:51,170 --> 00:33:00,280
por isso neste momento tenho apenas definido um índice 1 e eu posso fazer tanto a matriz $ [1] e $ array ['1 ']

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

370
00:33:06,250 --> 00:33:13,000
Então agora o que você acha 3 vai ser? >> [Aluno] 2. >> [Bowden] Eu estou supondo 2.

371
00:33:16,000 --> 00:33:18,690
Sim. É 2.

372
00:33:18,690 --> 00:33:24,790
O que se fizéssemos isso é 10, é 4? O que você acha 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
Meu palpite sobre o que o PHP faz - e eu acho que já vi isso antes -

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

376
00:33:39,760 --> 00:33:44,230
Isso nunca vai atribuir um índice de seqüência para 3. Será sempre um índice numérico.

377
00:33:44,230 --> 00:33:47,690
Por isso, mantém o controle do mais alto é atribuído até agora, que passa 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 disse antes, observe a forma como ele está a imprimir essa matriz.

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

381
00:34:06,850 --> 00:34:09,790
Ou mesmo vamos fazer -

382
00:34:15,760 --> 00:34:22,489
Eu acho que eu não coloquei a 0, mas é a impressão 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
E se eu mudar aqui? Ou vamos realmente mudar esses 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
Matrizes do PHP não são como a sua tabela regular de hash.

386
00:34:41,270 --> 00:34:45,570
É perfeitamente razoável pensar neles como tabelas de hash de 99% do tempo.

387
00:34:45,570 --> 00:34:53,790
Mas em suas tabelas de hash não há sentido da ordem em que as coisas estavam inseridos.

388
00:34:53,790 --> 00:34:56,639
Assim, logo que você inserir na tabela hash,

389
00:34:56,639 --> 00:35:00,590
assumir que não há lista de ligações e você pode julgar dentro de uma lista ligada

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

391
00:35:03,980 --> 00:35:10,060
Mas aqui estamos inseridos dois primeiro e sabe quando é imprimir essa matriz que 2 vem em primeiro lugar.

392
00:35:10,060 --> 00:35:13,090
Não imprimi-lo em apenas um fim qualquer.

393
00:35:13,090 --> 00:35:17,550
A estrutura de dados técnicos que ele está usando é um mapa ordenado,

394
00:35:17,550 --> 00:35:24,690
assim que mapeia chaves para valores e recorda a ordem em que as chaves foram inseridas.

395
00:35:24,690 --> 00:35:31,600
Basicamente é para algumas complicações em que é chato para realmente -

396
00:35:31,600 --> 00:35:34,510
Vamos dizer que você tem uma matriz 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
e você quer tirar índice 2.

398
00:35:37,700 --> 00:35:47,750
Uma maneira de fazê-lo, vamos 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 remover as duas variáveis ​​e índices da matriz.

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

402
00:35:58,630 --> 00:36:03,430
Agora, o que isso vai parecer? 2 é apenas ido embora, de modo que é perfeitamente bem.

403
00:36:03,430 --> 00:36:11,670
Mais irritante é se você quer que as coisas realmente ser como uma matriz.

404
00:36:11,670 --> 00:36:14,910
Vou colocar números aleatórios.

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 seja apenas como uma matriz C, onde ele vai de 0 a duração - 1

407
00:36:26,860 --> 00:36:30,810
e eu posso iterar sobre ele como tal.

408
00:36:30,810 --> 00:36:38,520
Mas assim que eu remover o segundo índice, que estava no índice 3 não agora se tornou índice 2.

409
00:36:38,520 --> 00:36:44,790
Em vez disso, apenas remove esse índice e agora você vai de 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Isto é perfeitamente razoável.

411
00:36:48,740 --> 00:36:53,950
É apenas irritante e você tem que fazer coisas como emenda matriz. Sim.

412
00:36:53,950 --> 00:36:57,200
>> [Aluno] O que aconteceria se você tivesse um loop

413
00:36:57,200 --> 00:36:59,630
e você queria passar por cima de todos os elementos?

414
00:36:59,630 --> 00:37:02,290
Quando bateu dois, seria render sempre?

415
00:37:02,290 --> 00:37:10,150
Iteração sobre uma matriz. Há duas maneiras de fazer isso.

416
00:37:10,150 --> 00:37:12,770
Você pode usar um regular para loop.

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

418
00:37:22,000 --> 00:37:27,420
A maioria das linguagens, eu diria, têm algum tipo de comprimento ou len ou algo

419
00:37:27,420 --> 00:37:30,470
indica o comprimento de uma matriz.

420
00:37:30,470 --> 00:37:32,820
No PHP é contagem.

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

422
00:37:36,160 --> 00:37:42,950
Vamos apenas impressão ($ array [$ i]);

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

424
00:37:48,820 --> 00:37:51,610
Ele só vai falhar.

425
00:37:51,610 --> 00:38:03,020
Esta é a razão que, para a maior parte, você nunca precisa iterar sobre uma matriz como este.

426
00:38:03,020 --> 00:38:07,110
Pode ser um exagero, mas você nunca precisa iterar sobre uma matriz como esta

427
00:38:07,110 --> 00:38:19,410
porque o PHP fornece sua sintaxe foreach onde foreach (array $ quanto $ item).

428
00:38:19,410 --> 00:38:31,830
Agora, se nós imprimir ($ item); - nós discutir isso em um segundo - que funciona perfeitamente bem.

429
00:38:31,830 --> 00:38:38,960
A maneira que foreach está trabalhando é o primeiro argumento é a matriz que você está iterando.

430
00:38:38,960 --> 00:38:44,060
E o segundo argumento, item, através de cada passagem do loop

431
00:38:44,060 --> 00:38:52,690
que vai assumir a próxima coisa na matriz. Então lembre-se a matriz tem uma ordem.

432
00:38:52,690 --> 00:38:55,690
A primeira vez através do loop for, o item vai ser 123

433
00:38:55,690 --> 00:38:59,540
, então ele irá ser de 12, em seguida, ela será de 13, então ele irá ser de 23, então será 213.

434
00:38:59,540 --> 00:39:04,670
As coisas ficam realmente estranho quando você faz algo como foreach.

435
00:39:04,670 --> 00:39:07,480
Vamos ver o que acontece, porque você nunca deve fazer isso.

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 provavelmente foi o esperado.

438
00:39:26,030 --> 00:39:30,950
Você está interagindo sobre essa matriz, e cada vez que você está desconfigurar o primeiro índice.

439
00:39:30,950 --> 00:39:39,720
Então, para o índice 0, a primeira coisa item, assume valor 0, por isso vai ser 123.

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

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

442
00:39:57,480 --> 00:40:03,580
PHP_EOL é apenas mudança de linha, mas é tecnicamente mais portátil

443
00:40:03,580 --> 00:40:08,890
desde novas linhas no Windows é diferente de novas linhas no Mac e UNIX.

444
00:40:08,890 --> 00:40:18,040
No Windows nova linha é \ r \ n, enquanto que em qualquer outro lugar que tende apenas para ser \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL é configurado para que ele usa o que quer que a nova linha do seu sistema é.

446
00:40:25,150 --> 00:40:29,310
Assim que imprimir. Não vamos print_r ($ array) no final.

447
00:40:32,830 --> 00:40:37,390
Eu não tinha idéia de que isso seria o comportamento.

448
00:40:41,740 --> 00:40:48,960
Item ainda assume o valor de 12 mesmo que unset 12 antes de nós sempre tem para ele a partir da matriz.

449
00:40:52,770 --> 00:40:58,840
Não tome minha palavra sobre isso, mas parece que foreach cria uma cópia da matriz

450
00:40:58,840 --> 00:41:02,160
e então o item assume todos os valores de que a cópia.

451
00:41:02,160 --> 00:41:07,760
Assim, mesmo se você modificar a matriz dentro do loop for,

452
00:41:07,760 --> 00:41:17,240
ele não vai se importar. Item será assumir os valores originais.

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

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

455
00:41:24,460 --> 00:41:31,770
Mesmo que colocar "Olá" para a matriz, nunca item leva nesse valor.

456
00:41:31,770 --> 00:41:37,430
Há uma outra sintaxe para foreach laços

457
00:41:37,430 --> 00:41:45,900
onde você colocar duas variáveis ​​separadas por uma flecha.

458
00:41:45,900 --> 00:41:49,680
Esta primeira variável vai ser a chave deste valor,

459
00:41:49,680 --> 00:41:53,050
e esta segunda variável vai ser o mesmo item exato.

460
00:41:53,050 --> 00:42:01,610
Isso não é interessante aqui, mas se voltarmos ao nosso 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
aqui se apenas iterar para cada matriz como item, o item vai ser uma cada vez.

463
00:42:14,470 --> 00:42:18,170
Mas se nós também queremos saber a chave associada com esse item

464
00:42:18,170 --> 00:42:25,230
depois fazemos as $ chave -> item $.

465
00:42:25,230 --> 00:42:31,980
Então agora podemos fazer impressão (tecla $. ':'.

466
00:42:31,980 --> 00:42:39,380
Agora está iterando e impressão de cada chave e seu valor associado.

467
00:42:39,380 --> 00:42:47,030
>> Uma coisa adicional que podemos fazer em foreach loops é que você pode ver esta sintaxe.

468
00:42:47,030 --> 00:42:54,770
E comercial antes de nomes de variáveis ​​tendem a ser como o PHP faz referências.

469
00:42:54,770 --> 00:43:00,460
Onde as referências são muito semelhantes aos ponteiros,

470
00:43:00,460 --> 00:43:04,820
você não tem ponteiros, então você nunca lidar com a memória diretamente.

471
00:43:04,820 --> 00:43:12,620
Mas você tem referências onde uma variável refere-se a mesma coisa que outra variável.

472
00:43:12,620 --> 00:43:21,450
Aqui dentro, vamos fazer $ item. Vamos voltar a 1, 10.

473
00:43:21,450 --> 00:43:28,800
Vamos fazer $ item + +; que ainda existe em PHP. Você ainda pode fazer + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Eu tenho que imprimi-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 tivesse feito foreach (array $ quanto $ item) então o item será o valor 1

477
00:43:49,560 --> 00:43:54,190
pela primeira vez através do loop. Ele irá incrementar 1-2 e depois estamos a fazer.

478
00:43:54,190 --> 00:43:57,260
Então ele vai passar a segunda passagem do laço e esse item é de 10.

479
00:43:57,260 --> 00:44:01,570
É item de incrementos a 11, e depois que acabou jogado fora.

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

481
00:44:06,670 --> 00:44:09,070
Assim, o incremento que fizemos foi perdido.

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

483
00:44:13,410 --> 00:44:21,910
agora esse item é o mesmo item como este aqui. É a mesma coisa.

484
00:44:21,910 --> 00:44:26,820
Então item de R $ + + está modificando matriz 0.

485
00:44:29,330 --> 00:44:41,850
Basicamente, você também pode fazer $ k -> array $ item e você pode fazer [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Assim, uma outra maneira de fazer isso, nós somos livres para modificar item,

487
00:44:48,650 --> 00:44:54,070
mas isso não vai modificar a nossa matriz original.

488
00:44:54,070 --> 00:44:59,720
Mas se usarmos k, que é a nossa chave, então podemos apenas o índice em nossa matriz usando a chave

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

490
00:45:01,530 --> 00:45:05,410
Esta mais diretamente modifica nossa matriz original.

491
00:45:05,410 --> 00:45:10,690
Você pode até fazer isso se por algum motivo você queria que a capacidade de modificar -

492
00:45:10,690 --> 00:45:13,510
Na verdade, isso é perfeitamente razoável.

493
00:45:13,510 --> 00:45:16,020
Você não queria ter que escrever $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
você só queria escrever $ item + +, mas você ainda queria dizer if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
então incrementar item e, em seguida, imprimir a nossa matriz.

496
00:45:30,620 --> 00:45:36,290
Então agora o que nós esperamos print_r fazer? Que valores devem ser impressos?

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

498
00:45:51,940 --> 00:45:55,670
>> Você, provavelmente, muito raramente, ou nunca, será necessário definir funções em PHP,

499
00:45:55,670 --> 00:46:03,370
mas você pode ver algo semelhante, onde você define uma função como qualquer função.

500
00:46:03,370 --> 00:46:09,900
Normalmente você diria ($ foo, $ bar) e, então, definir que ele seja o que for.

501
00:46:09,900 --> 00:46:17,580
Mas se eu fizer isso, então isso significa que o que chama de qualquer coisa,

502
00:46:17,580 --> 00:46:25,110
qualquer que chama baz, de modo que o primeiro argumento passado para baz pode ser alterado.

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

504
00:46:38,100 --> 00:46:48,020
e aqui dentro, vamos fazer baz ($ item);

505
00:46:48,020 --> 00:46:52,250
Agora nós estamos chamando uma função.

506
00:46:52,250 --> 00:46:56,780
O argumento é tomado por referência, o que significa que, se modificá-lo

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

508
00:47:00,390 --> 00:47:04,420
E a impressão desse esperamos - a menos que eu errei sintaxe - temos 2, 11,

509
00:47:04,420 --> 00:47:06,300
assim foi, na verdade, incrementado.

510
00:47:06,300 --> 00:47:08,790
Observe que precisamos referências em dois lugares.

511
00:47:08,790 --> 00:47:13,050
E se eu fiz isso? O que isso significa?

512
00:47:13,050 --> 00:47:15,810
[Aluno] vai mudar. Sim >>.

513
00:47:15,810 --> 00:47:18,290
Item é apenas uma cópia do valor na matriz.

514
00:47:18,290 --> 00:47:26,670
Assim, o item irá mudar a 2, mas a matriz ['a'] ainda será 1.

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

516
00:47:32,560 --> 00:47:39,260
Agora item é enviado como cópia de Baz.

517
00:47:39,260 --> 00:47:46,330
Portanto, a cópia do argumento será incrementado para 2,

518
00:47:46,330 --> 00:47:49,240
mas o item em si nunca foi incrementado para 2.

519
00:47:49,240 --> 00:47:52,880
E item é a mesma coisa que o suporte de matriz que seja,

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

521
00:47:55,380 --> 00:47:57,960
Assim, ambos os lugares precisam.

522
00:47:57,960 --> 00:48:03,830
>> PHP é geralmente muito inteligente sobre isso.

523
00:48:03,830 --> 00:48:06,570
Você pode pensar que eu quero passar por referência -

524
00:48:06,570 --> 00:48:09,560
Esta foi realmente uma pergunta sobre uma das Série de Exercícios.

525
00:48:09,560 --> 00:48:14,480
Foi uma coisa questions.txt onde disse:

526
00:48:14,480 --> 00:48:19,280
Por que você quer passar essa estrutura por referência?

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

528
00:48:21,250 --> 00:48:25,100
[Aluno] Então você não tem que copiar algo grande. Sim >>.

529
00:48:25,100 --> 00:48:32,920
Uma estrutura pode ser arbitrariamente grande, e quando você passar a estrutura como um argumento

530
00:48:32,920 --> 00:48:36,800
ele precisa copiar a estrutura inteira para passá-lo para a função,

531
00:48:36,800 --> 00:48:40,410
enquanto que se você apenas passar a estrutura por referência

532
00:48:40,410 --> 00:48:46,530
então ele só precisa copiar um endereço de 4 bytes como argumento para a função.

533
00:48:48,520 --> 00:48:52,320
PHP é um pouco mais inteligente do que isso.

534
00:48:52,320 --> 00:49:00,650
Se eu tiver alguma função e eu passar para ele uma série de coisas 1000,

535
00:49:00,650 --> 00:49:03,990
isso significa que ele vai ter que copiar todo 1.000 dessas coisas

536
00:49:03,990 --> 00:49:10,450
para passar para a função? Ele não tem que fazer isso imediatamente.

537
00:49:10,450 --> 00:49:15,940
Se dentro desta função nunca realmente modifica foo,

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

539
00:49:22,660 --> 00:49:26,460
Observe que na verdade nunca modificou o interior argumento dessa função,

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

541
00:49:30,010 --> 00:49:32,100
porque não é modificá-lo.

542
00:49:32,100 --> 00:49:39,240
Assim, a maneira PHP obras é os argumentos são sempre passados ​​por referência

543
00:49:39,240 --> 00:49:42,170
até que você realmente tentar modificá-lo.

544
00:49:42,170 --> 00:49:51,160
Agora, se eu digo $ foo + +, que vai agora fazer uma cópia do foo original e modificar a cópia.

545
00:49:51,160 --> 00:49:53,090
Isso economiza algum tempo.

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

547
00:49:58,210 --> 00:50:02,360
ele não precisa para fazer a cópia,

548
00:50:02,360 --> 00:50:06,640
enquanto que se nós só colocamos esse comercial que significa que nem mesmo copiá-lo

549
00:50:06,640 --> 00:50:08,640
mesmo se você modificá-lo.

550
00:50:08,640 --> 00:50:10,680
Esse comportamento é chamado de cópia na gravação.

551
00:50:10,680 --> 00:50:17,380
Você vai vê-lo em outros lugares, especialmente se você tirar um curso de sistema operacional.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write é um padrão bastante usual em que você não precisa fazer uma cópia de algo

553
00:50:23,880 --> 00:50:26,650
a menos que seja realmente mudando. Sim.

554
00:50:26,650 --> 00:50:29,520
[Aluno] E se você tivesse o incremento dentro do teste,

555
00:50:29,520 --> 00:50:33,700
tão somente o elemento 1 de 1000 terá de ser mudado?

556
00:50:33,700 --> 00:50:38,770
Não tenho a certeza.

557
00:50:38,770 --> 00:50:51,250
Eu acho que seria copiar a coisa toda, mas é possível que ele é inteligente o suficiente para que -

558
00:50:51,250 --> 00:51:00,020
Na verdade, o que eu estou pensando é imaginar que tínhamos uma matriz que fica assim: $ array2 = [

559
00:51:00,020 --> 00:51:11,000
Então índice de 'a' é uma matriz de [1 2 3 4], índice e 'b' é uma matriz de qualquer coisa.

560
00:51:11,000 --> 00:51:15,380
Eu preciso de vírgulas entre todos esses. Imagine que há vírgulas.

561
00:51:15,380 --> 00:51:21,210
Em seguida, 'c' é o 3 valor.

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

563
00:51:26,290 --> 00:51:33,440
Agora vamos dizer que temos $ baz ($ array2);

564
00:51:33,440 --> 00:51:36,540
onde baz não tomar esta referência.

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

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

567
00:51:52,340 --> 00:51:57,010
e em seguida, é a modificação de um índice específico da matriz, incrementando-lo.

568
00:51:57,010 --> 00:52:01,090
Eu honestamente não tenho idéia do que o PHP vai fazer.

569
00:52:01,090 --> 00:52:07,200
Ele pode facilmente fazer uma cópia de toda a coisa, mas se ele é inteligente,

570
00:52:07,200 --> 00:52:15,030
ele vai fazer uma cópia destas chaves, onde esta terá seu valor distinto

571
00:52:15,030 --> 00:52:20,620
mas esta ainda pode apontar para a mesma matriz 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
e isto pode ainda apontar para a mesma matriz.

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

574
00:52:28,900 --> 00:52:45,950
Passamos essa matriz onde esse cara pontos a 3, isso aponta para cara [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
esse cara aponta para [34, ...]

576
00:52:51,350 --> 00:52:58,590
Agora que estamos passando para baz, estamos modificando isso.

577
00:52:58,590 --> 00:53:03,550
Se o PHP é inteligente, ele pode apenas fazer -

578
00:53:11,850 --> 00:53:18,230
Nós ainda tinha que copiar alguma memória, mas se houvesse essas subarrays enormes aninhadas

579
00:53:18,230 --> 00:53:21,560
nós não precisamos copiar os.

580
00:53:21,560 --> 00:53:27,530
Eu não sei se é isso que ele faz, mas posso imaginar que ele está fazendo isso.

581
00:53:29,050 --> 00:53:36,690
Esta também é uma vantagem muito grande de C sobre PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP torna a vida muito mais fácil para um monte de coisas,

583
00:53:40,320 --> 00:53:45,060
mas você meio que tem absolutamente nenhuma idéia de como ele irá executar

584
00:53:45,060 --> 00:53:52,530
porque eu não tenho nenhuma idéia debaixo do capô quando se está a fazer estas cópias de coisas,

585
00:53:52,530 --> 00:53:55,170
oh, é que vai ser uma cópia de tempo constante,

586
00:53:55,170 --> 00:54:01,140
É só vai mudar um ponteiro, é que vai ser uma cópia ridiculamente difícil linear?

587
00:54:01,140 --> 00:54:03,000
E se não pode encontrar espaço?

588
00:54:03,000 --> 00:54:06,760
Será que precisa então para executar a coleta de lixo para conseguir espaço um pouco mais?

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

590
00:54:11,210 --> 00:54:13,600
Em C você não tem que se preocupar com essas coisas.

591
00:54:13,600 --> 00:54:19,780
Cada linha que você escreve você pode raciocinar muito bonita sobre como vai executar.

592
00:54:26,800 --> 00:54:29,150
>> Vamos olhar para estes.

593
00:54:35,400 --> 00:54:37,520
Que bom é que você não tem que lidar com funções de hash,

594
00:54:37,520 --> 00:54:39,010
listas ligadas, ou qualquer coisa assim?

595
00:54:39,010 --> 00:54:41,980
Desde que trabalho com tabelas de hash é tão fácil agora, aqui está um quebra-cabeça divertido para trabalhar.

596
00:54:41,980 --> 00:54:45,920
Abrir um arquivo chamado unique.php e nela escrever um programa PHP

597
00:54:45,920 --> 00:54:48,330
(Também conhecido como um "script").

598
00:54:48,330 --> 00:54:55,700
Nós tendemos a chamá-los de scripts se eles são coisas pequenas que você executa na linha de comando.

599
00:54:55,700 --> 00:55:02,950
Basicamente, qualquer linguagem que você não compilar, mas você está indo para executar o arquivo executável

600
00:55:02,950 --> 00:55:05,920
na linha de comando, você pode chamar esse script executável.

601
00:55:05,920 --> 00:55:08,510
Eu poderia muito bem escrever um programa em C que faz isso,

602
00:55:08,510 --> 00:55:12,300
mas eu não chamá-lo de um script desde que eu compilar e executar o binário.

603
00:55:12,300 --> 00:55:15,480
Mas este programa PHP vamos chamar um script.

604
00:55:15,480 --> 00:55:23,830
Ou se escreveu em Python ou Perl ou Node.js ou qualquer uma dessas coisas,

605
00:55:23,830 --> 00:55:26,500
nós chamá-los de todos os scripts porque você executá-los na linha de comando

606
00:55:26,500 --> 00:55:30,040
mas não compilá-los.

607
00:55:30,860 --> 00:55:33,400
Nós poderíamos fazer isso muito rapidamente.

608
00:55:36,960 --> 00:55:41,480
Nós não estamos indo para usar argv. Vamos apenas explodir por isso.

609
00:55:41,480 --> 00:55:45,730
Chame-o único, escrever um programa.

610
00:55:45,730 --> 00:55:49,400
Você pode assumir que a entrada irá conter uma palavra por linha.

611
00:55:49,400 --> 00:55:52,020
Na verdade, argv será bem simples de se usar.

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

613
00:56:08,550 --> 00:56:13,750
Primeiro de tudo, queremos verificar se foram passados ​​um argumento de linha de comando.

614
00:56:13,750 --> 00:56:20,900
Assim como seria de esperar argc e argv em C, ainda temos aqueles em PHP.

615
00:56:20,900 --> 00:56:33,900
Então, se ($ argc! == 2) então eu não vou lidar com a impressão de uma mensagem ou qualquer coisa.

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

617
00:56:37,340 --> 00:56:41,340
Eu também poderia retornar 1.

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

619
00:56:53,180 --> 00:56:57,820
Normalmente, você está em uma função chamada por uma função chamada por uma função chamada por uma função.

620
00:56:57,820 --> 00:57:02,070
E se algo der errado e você só quer sair tudo inteiramente,

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

622
00:57:05,680 --> 00:57:08,160
Isto também existe em C.

623
00:57:08,160 --> 00:57:10,700
Se você estiver em uma função em uma função em uma função em uma função

624
00:57:10,700 --> 00:57:17,540
e você quer apenas matar o programa, você pode chamar de saída e ele vai sair.

625
00:57:17,540 --> 00:57:23,120
Mas em PHP é ainda mais raro que estamos neste nível superior.

626
00:57:23,120 --> 00:57:26,090
Normalmente estamos dentro de algum tipo de função, por isso chamamos de saída

627
00:57:26,090 --> 00:57:29,650
de modo que não temos de voltar-se uma coisa que, então, percebe que há um erro

628
00:57:29,650 --> 00:57:32,270
assim que retorna-se se reconhece que houve um erro.

629
00:57:32,270 --> 00:57:35,270
Nós não querem lidar com isso, então sair (1);

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

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

632
00:57:44,000 --> 00:57:46,760
Os argumentos vão olhar bastante semelhantes.

633
00:57:46,760 --> 00:57:51,600
Queremos fopen ($ argv [1], e queremos abri-lo para leitura.

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

635
00:57:55,720 --> 00:58:02,180
Isso parece muito semelhante à forma como C faz isso, exceto que não temos a dizer * FILE.

636
00:58:02,180 --> 00:58:06,170
Em vez disso, apenas dizer $ f. Okay.

637
00:58:06,170 --> 00:58:17,190
Na verdade, eu acho que isso ainda nos dá uma dica de PHP função chamada arquivo. Arquivo PHP.

638
00:58:17,190 --> 00:58:23,990
O que é que isto vai fazer é ler um arquivo inteiro em uma matriz.

639
00:58:23,990 --> 00:58:29,770
Você não precisa mesmo de fopen-lo. Ele vai fazer isso por você.

640
00:58:37,450 --> 00:58:43,700
Então $ linhas = file ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Agora, todas as linhas do arquivo são em linhas. Agora queremos classificar as linhas.

642
00:58:49,680 --> 00:58:52,180
Como podemos classificar as linhas?

643
00:58:52,180 --> 00:58:54,920
Nós classificar as linhas.

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

645
00:58:58,080 --> 00:59:05,580
Provavelmente a maneira mais fácil é foreach ($ lines as $ linha) echo $ linha;

646
00:59:05,580 --> 00:59:10,960
[Aluno] não seria mesmo de cruzar as linhas, fazendo referência a algo em espécie?

647
00:59:10,960 --> 00:59:28,850
Este é o lugar onde tipo pode ser definido como uma espécie de função (& $ array).

648
00:59:28,850 --> 00:59:32,650
Quando você chama a função que você não passe por referência.

649
00:59:32,650 --> 00:59:36,900
É a função que define como tomá-lo como referência.

650
00:59:36,900 --> 00:59:40,900
Este é, na verdade, exatamente o que deu errado

651
00:59:40,900 --> 00:59:46,220
quando colocamos tudo em nossos servidores quando fomos 5,3-5,4.

652
00:59:46,220 --> 00:59:53,800
Até 5.4, isso era perfeitamente razoável.

653
00:59:53,800 --> 00:59:58,740
Uma função não espera para levá-lo como referência, mas você pode passar isso como referência

654
00:59:58,740 --> 01:00:02,860
por isso, se a função não acontece para modificá-lo, ainda é modificado.

655
01:00:02,860 --> 01:00:05,850
A partir de 5.4, você não deveria fazer isso.

656
01:00:05,850 --> 01:00:11,740
Então, agora a única maneira de você passar por referência é se a função explicitamente o faz.

657
01:00:11,740 --> 01:00:19,840
Se você não quer que ele para modificá-lo, então você precisa fazer copy = $ $ linhas e cópia passe.

658
01:00:19,840 --> 01:00:24,820
Então, agora as linhas serão preservados e cópia será alterado.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Eu poderia ter sujado alguma coisa.

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

661
01:00:38,320 --> 01:00:43,850
Não vai ser algo que faz isso para nós.

662
01:00:43,850 --> 01:00:45,820
Ele não está lá.

663
01:00:45,820 --> 01:00:52,140
Observe que quando você ler o manual que o primeiro argumento é esperado para ser um array

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

665
01:00:58,160 --> 01:01:03,540
Por que isso está reclamando comigo? Porque eu tenho esse tipo de função ainda aqui que eu não quero.

666
01:01:03,540 --> 01:01:09,210
Ok, php.unique.php. Eu não passar um argumento, porque eu não tenho um arquivo.

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

668
01:01:13,560 --> 01:01:19,080
Aqui está test.php todos impressos em uma ordem legal classificados.

669
01:01:19,080 --> 01:01:24,600
Observe que ordem de classificação é meio estranho para um arquivo de código

670
01:01:24,600 --> 01:01:27,460
porque todas as nossas linhas em branco vão vir em primeiro lugar

671
01:01:27,460 --> 01:01:30,190
então vão vir todos os nossos recortes de nível 1

672
01:01:30,190 --> 01:01:33,360
depois vêm todos os nossos recortes não.

673
01:01:33,360 --> 01:01:38,620
Sim. >> [Aluno] Portanto, para o código-fonte não foi passado por referência?

674
01:01:38,620 --> 01:01:42,240
É que geralmente passados ​​por valor?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Quando você chamar uma função, ele nunca determina se ele foi passado por referência.

676
01:01:50,240 --> 01:01:53,960
É a definição da função que determina se ele foi passado por referência.

677
01:01:53,960 --> 01:01:59,450
E olhando para a definição da função de classificação ou apenas olhando para isso,

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

679
01:02:02,820 --> 01:02:07,160
Portanto, independentemente de se você quer tomar por referência, toma por referência.

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

681
01:02:10,200 --> 01:02:17,400
Este não é apenas permitido. Você não tem permissão para fazer isso. >> [Aluno] Ah, ok.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Isso, tipo vai ter linhas de referência e modificá-lo.

683
01:02:22,410 --> 01:02:26,850
E, novamente, se você não quer que ele faça isso, você pode fazer uma cópia do tipo.

684
01:02:26,850 --> 01:02:35,850
Mesmo neste caso, a cópia não é, na verdade, uma cópia de linhas.

685
01:02:35,850 --> 01:02:40,620
Ele só aponta para a mesma coisa, até que primeiro é modificado,

686
01:02:40,620 --> 01:02:44,430
onde está primeiro vai ser modificado na função de classificação,

687
01:02:44,430 --> 01:02:50,940
onde, porque é cópia na gravação, agora uma cópia do exemplar vai ser feita.

688
01:02:57,500 --> 01:03:04,250
Você também pode fazer isso. Esse é o lugar que você pode ver e comercial.

689
01:03:04,250 --> 01:03:07,190
Você vê isso em loops foreach, você vê-lo em declarações de função,

690
01:03:07,190 --> 01:03:10,040
e você vê-lo quando apenas a atribuição de variáveis.

691
01:03:10,040 --> 01:03:12,350
Agora nós não realizamos nada, fazendo isso

692
01:03:12,350 --> 01:03:15,600
porque cópia e linhas são literalmente a mesma coisa.

693
01:03:15,600 --> 01:03:19,940
Você pode usar linhas e copiar alternadamente.

694
01:03:19,940 --> 01:03:25,430
Você pode fazer unset (cópia $) e que não faz linhas unset,

695
01:03:25,430 --> 01:03:29,120
você acabou de perder sua referência para a mesma coisa.

696
01:03:29,120 --> 01:03:33,440
Então, a partir deste ponto, agora linhas é a única maneira que você pode acessar linhas.

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

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

699
01:03:42,460 --> 01:03:45,880
[Aluno] Completamente off topic, mas você não tem que fechar com o PHP - >> Você não.

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

701
01:03:47,730 --> 01:03:53,790
[Bowden] Eu iria tão longe a ponto de dizer que é uma má prática para fechá-las.

702
01:03:53,790 --> 01:03:57,580
Isso é provavelmente um exagero, especialmente em um script,

703
01:03:57,580 --> 01:04:03,740
mas vamos ver o que acontece se eu fazer isso.

704
01:04:03,740 --> 01:04:08,890
Que não fez nada. E se eu queria - [suspira]

705
01:04:13,870 --> 01:04:16,960
Eu preciso passar um argumento.

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

707
01:04:24,340 --> 01:04:28,310
Então php.unique.php com um argumento.

708
01:04:28,310 --> 01:04:30,980
Agora eu nem preciso disso.

709
01:04:34,520 --> 01:04:37,740
Vou passar para ele um argumento válido.

710
01:04:37,740 --> 01:04:42,050
Este impresso o que é impressão.

711
01:04:45,260 --> 01:04:50,080
Eu estou imprimindo cópia e cópia não existe. Assim linhas.

712
01:04:53,650 --> 01:04:58,270
É impresso tudo, e então perceber todo esse lixo aqui,

713
01:04:58,270 --> 01:05:06,690
porque em nada PHP que está fora das tags PHP

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

715
01:05:09,520 --> 01:05:18,050
É por isso que o HTML, é tão bom que eu posso fazer div blá, blá, blá de classe ou o que seja,

716
01:05:18,050 --> 01:05:25,140
blá, blá, blá e depois fazer algum código PHP e depois fazer div final.

717
01:05:25,140 --> 01:05:36,460
E agora a impressão isso eu recebo minha div agradável em cima, tudo que o PHP impresso, div na parte inferior.

718
01:05:36,460 --> 01:05:43,510
Desastroso quando algo assim acontece, o que é bastante comum,

719
01:05:43,510 --> 01:05:47,930
apenas uma nova linha perdida no fundo do arquivo.

720
01:05:47,930 --> 01:05:50,940
Você não acha que seria a de um grande negócio

721
01:05:50,940 --> 01:05:58,660
até você considerar o fato de que com navegadores -

722
01:05:58,660 --> 01:06:03,880
>> Como redireciona trabalho ou, basicamente, a obra de cabeçalhos,

723
01:06:03,880 --> 01:06:07,980
quando você faz a sua ligação a um site e envia de volta todos esses cabeçalhos e coisas

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

725
01:06:12,020 --> 01:06:18,230
cabeçalhos são válidos apenas até o primeiro byte de dados é enviado.

726
01:06:18,230 --> 01:06:23,140
Pode redireccionar milhares de vezes, mas, logo que o primeiro byte de dados é enviado

727
01:06:23,140 --> 01:06:26,120
você não deveria redirecionar novamente.

728
01:06:26,120 --> 01:06:31,860
>> Se tiver uma nova linha estática na parte inferior de um ficheiro

729
01:06:31,860 --> 01:06:37,260
e digamos que você use essa função e então você quer -

730
01:06:41,580 --> 01:06:52,870
Vamos dizer que é outro arquivo que é index.php e você require_once algo -

731
01:06:52,870 --> 01:06:56,920
Eu não consigo pensar em um bom exemplo disso.

732
01:06:56,920 --> 01:07:04,740
O problema acontece quando esta linha na parte inferior fica ecoou.

733
01:07:04,740 --> 01:07:08,660
Você não quer nada ter sido ecoado ainda.

734
01:07:10,820 --> 01:07:15,700
Mesmo que você não tinha a intenção de ficar ecoou nada, algo que se repetiu

735
01:07:15,700 --> 01:07:17,990
e agora você não deve enviar cabeçalhos mais nenhuma

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

737
01:07:22,170 --> 01:07:24,420
Você só não precisa dessas tags de fechamento.

738
01:07:24,420 --> 01:07:27,420
Se você está pensando em fazer algo com HTML -

739
01:07:27,420 --> 01:07:30,490
e é perfeitamente razoável a fazer aqui o que div

740
01:07:30,490 --> 01:07:39,450
e então, neste ponto você pode ou não pode incluí-los.

741
01:07:39,450 --> 01:07:41,590
Isso realmente não importa.

742
01:07:41,590 --> 01:07:45,450
Mas em scripts PHP é raro para a fechar.

743
01:07:45,450 --> 01:07:50,400
Quando tudo é PHP, absolutamente tudo,

744
01:07:50,400 --> 01:07:55,460
você realmente não precisa fechá-lo / você não deve fechá-lo.

745
01:08:02,030 --> 01:08:05,720
>> Lidar com cordas é muito mais agradável do que em C.

746
01:08:05,720 --> 01:08:09,470
No PHP, você pode especificar uma string com aspas simples ou duplas.

747
01:08:09,470 --> 01:08:12,820
Com aspas simples você não pode usar "escape" sequências.

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

749
01:08:19,920 --> 01:08:24,010
Então printf é muito raro em PHP.

750
01:08:24,010 --> 01:08:32,290
Eu acho que eu iria usar printf se eu queria fazer um tipo de coisa - em que você usou pset 5 sprintf ou o que quer.

751
01:08:32,290 --> 01:08:36,060
Mas você quer fazer 001.jpg 002.jpg e.

752
01:08:36,060 --> 01:08:40,300
Assim, para esse tipo de coisa em que eu realmente quero formatar o texto que eu iria usar printf.

753
01:08:40,300 --> 01:08:44,689
Mas caso contrário, eu iria usar apenas 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 apenas diferenciar os detalhes entre aspas simples e aspas duplas.

756
01:09:00,170 --> 01:09:07,490
A maior diferença é que aspas simples, ele será impresso literalmente.

757
01:09:07,490 --> 01:09:15,390
Não há nenhum tipo de dados char em PHP, ao contrário de C, de modo que este é equivalente a este.

758
01:09:15,390 --> 01:09:17,970
Eles são duas cordas.

759
01:09:17,970 --> 01:09:29,180
E a coisa agradável sobre cordas aspas simples é que eu poderia dizer 'Olá mundo!' blá, blá, blá,

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

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

762
01:09:38,260 --> 01:09:40,680
Vamos nos livrar de todas as nossas coisas.

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

764
01:09:48,569 --> 01:09:56,570
É, literalmente, impresso todas essas coisas: Sinais de dólar,

765
01:09:56,570 --> 01:09:58,770
barra invertida n, qual você acha que seria newlines -

766
01:09:58,770 --> 01:10:01,500
todas essas coisas ele imprime literalmente.

767
01:10:01,500 --> 01:10:05,650
A única coisa que você precisa escapar são aspas simples

768
01:10:05,650 --> 01:10:09,470
porque caso contrário, poderia pensar que está fechando as aspas simples.

769
01:10:09,470 --> 01:10:15,050
Aspas, completamente diferentes.

770
01:10:20,300 --> 01:10:25,870
Nós já vemos o destaque da sintaxe é cluing-nos para o que está prestes a ir terrivelmente errado.

771
01:10:25,870 --> 01:10:36,190
php.unique. Indefinido variável: wooo porque esta é interpretada como uma variável chamada wooo.

772
01:10:36,190 --> 01:10:42,400
Aspas duplas permitem que você inserir variáveis ​​-

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

774
01:10:52,730 --> 01:10:58,020
Então echo "Olá, meu nome é $ nome!";

775
01:10:58,020 --> 01:11:09,260
Ela reconhece esta como uma variável.

776
01:11:09,260 --> 01:11:21,210
Quando eu executo isso - e vou inserir uma nova linha - Oi, meu nome é Rob! e Olá mundo!

777
01:11:21,210 --> 01:11:24,910
Isto é porque nunca tirei a impressão de wooo acima.

778
01:11:24,910 --> 01:11:30,020
Há um passo a mais que você pode fazer.

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 quiser imprimir o primeiro índice de matriz?

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

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

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

784
01:11:54,510 --> 01:11:59,860
Oi, meu nome é 1! o que não é o que eu queria.

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

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

787
01:12:18,450 --> 01:12:21,440
É assim que eu teria que escrever.

788
01:12:26,350 --> 01:12:32,160
Aspas simples inesperado (T_ENCAPSED blá, blá, blá, blá, blá).

789
01:12:32,160 --> 01:12:41,780
A ideia é a de que ele não está reconhecendo isto como parte da matriz.

790
01:12:41,780 --> 01:12:46,620
Não está reconhecendo isso como matriz indexada por uma carta.

791
01:12:46,620 --> 01:12:49,870
Você quer fazer isso cercado por chaves,

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

793
01:12:54,730 --> 01:13:00,340
que é a palavra que usamos para magicamente inserção dessas variáveis ​​para os lugares certos.

794
01:13:00,340 --> 01:13:04,280
Agora fazer isso, php.unique, e Oi, meu nome é 1! como esperado

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

796
01:13:14,110 --> 01:13:23,130
Uma coisa que é uma espécie de bom sobre aspas simples é que -

797
01:13:23,130 --> 01:13:28,480
Há algum custo para interpolação.

798
01:13:30,520 --> 01:13:35,100
Se você usar aspas duplas, o intérprete tem que passar por cima essa seqüência,

799
01:13:35,100 --> 01:13:41,500
certificando-se de que, "Oh, aqui está uma variável. Agora eu preciso ir buscar essa variável e inseri-lo aqui."

800
01:13:41,500 --> 01:13:48,930
Mesmo se você não usar todas as variáveis,

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

802
01:13:52,220 --> 01:13:56,800
mas ainda vai ser mais lento porque ele precisa passar por cima das aspas

803
01:13:56,800 --> 01:14:00,130
à procura de coisas que precisam ser interpolados.

804
01:14:00,130 --> 01:14:05,360
Então citações individuais podem ser um pouco mais rápido se nada precisa ser interpolados,

805
01:14:05,360 --> 01:14:15,650
e eu ainda tendem a usar aspas simples para "Oi, meu nome é '. $ Array ['a'] de qualquer maneira.

806
01:14:15,650 --> 01:14:20,430
Isso vai ser equivalente ao que tínhamos antes.

807
01:14:24,840 --> 01:14:28,440
Mas é uma questão de preferência.

808
01:14:28,440 --> 01:14:34,750
Se você estiver usando PHP, você provavelmente não se importa com a diferença de velocidade.

809
01:14:34,750 --> 01:14:39,480
Não é o suficiente para raciocinar-los para começar.

810
01:14:39,480 --> 01:14:43,030
>> Todas as perguntas finais?

811
01:14:47,430 --> 01:14:51,710
>> Na verdade, nem sequer passar por tudo isso, mas este material era chato.

812
01:14:51,710 --> 01:14:59,080
A última coisa que é uma espécie de bom no PHP é quando você está lidando com HTML,

813
01:14:59,080 --> 01:15:06,450
você vai usá-lo um pouco, então a sintaxe bom atalho para a impressão de uma variável.

814
01:15:32,400 --> 01:15:36,730
Sem colocar PHP aqui, isso é chamado de tags 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
Recomenda-se colocar php.

817
01:15:48,640 --> 01:15:55,770
Este ainda é suportado, tags para curtas com o <? = Ainda estão perfeitamente bem.

818
01:15:55,770 --> 01:16:02,480
É apoiado por padrão, então você pode usá-los como quiser, e eles são muito conveniente.

819
01:16:02,480 --> 01:16:05,700
>> Alguma pergunta?

820
01:16:07,780 --> 01:16:09,270
Tudo bem.

821
01:16:10,840 --> 01:16:13,800
>> Fique elegante, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Risos]

823
01:16:18,620 --> 01:16:22,660
Tchau. [Risos]

824
01:16:24,350 --> 01:16:28,470
[Aplausos] [risos]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]