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

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

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

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Sejam bem-vindos. Esta é uma revisão para questionário 1.

5
00:00:11,610 --> 00:00:15,040
Assim como um aviso, este é - quero dizer, vamos tentar cobrir

6
00:00:15,040 --> 00:00:17,770
tanto material quanto possível, mas isso não significa que

7
00:00:17,770 --> 00:00:20,780
nós vamos cobrir todas as coisas que podem ser em questionário 1.

8
00:00:20,780 --> 00:00:25,270
Então não se esqueça que você também dar uma olhada em aula, seções, tudo o que você puder.

9
00:00:25,270 --> 00:00:28,240
Teste 1 vai ser na quarta-feira, próxima quarta-feira.

10
00:00:28,240 --> 00:00:33,800
Então não deixe de estudar. Vai ser, praticamente, como o primeiro teste

11
00:00:33,800 --> 00:00:36,390
quanto ao seu formato, mas provavelmente vai ser muito mais difícil.

12
00:00:36,390 --> 00:00:39,600
Pelo menos, no ano passado, quando eu tirei 50, eu pensei que era muito mais difícil.

13
00:00:39,600 --> 00:00:42,410
Portanto, estude muito.

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

15
00:00:45,190 --> 00:00:47,910
Isso é algo que um monte de gente acha que é complexo,

16
00:00:47,910 --> 00:00:51,930
mas eu vou tentar torná-lo tão fácil quanto possível.

17
00:00:51,930 --> 00:00:56,330
Primeiro de tudo, o que nós queremos que vocês conhecem para teste 1 é

18
00:00:56,330 --> 00:01:00,970
compreender as descrições conceituais de cada uma das estruturas de dados que eu vou apresentar.

19
00:01:00,970 --> 00:01:03,960
Isso significa que você não tem que realmente

20
00:01:03,960 --> 00:01:07,020
implementar uma tabela hash em seu questionário 1.

21
00:01:07,020 --> 00:01:10,250
Nós não queremos que você implemente uma tabela hash inteiro, talvez vamos tentar

22
00:01:10,250 --> 00:01:13,090
para fazer você implementar algumas funções,

23
00:01:13,090 --> 00:01:16,940
as operações mais comuns, mas não vai fazer você implementar tudo.

24
00:01:16,940 --> 00:01:21,010
Por isso, é importante que você entenda o conceito por trás de cada estrutura de dados

25
00:01:21,010 --> 00:01:23,510
e também que você é capaz de codificar em C,

26
00:01:23,510 --> 00:01:27,880
apenas as operações mais comuns que têm para cada estrutura de dados.

27
00:01:27,880 --> 00:01:30,090
E também ser capaz de analisar os ponteiros e estruturas,

28
00:01:30,090 --> 00:01:33,470
porque eles aparecem muito nestas estruturas de dados.

29
00:01:33,470 --> 00:01:37,380
>> Em primeiro lugar, as listas ligadas. Listas encadeadas são realmente muito semelhantes a arrays,

30
00:01:37,380 --> 00:01:39,930
mas a diferença entre uma lista encadeada e uma matriz,

31
00:01:39,930 --> 00:01:45,160
em primeiro lugar, que é uma lista encadeada tem um tamanho muito flexível,

32
00:01:45,160 --> 00:01:50,060
enquanto que em matrizes tem que quer escolher um tamanho muito grande para a matriz,

33
00:01:50,060 --> 00:01:53,710
para que você saiba que você vai ser capaz de armazenar todos os seus dados em que matriz,

34
00:01:53,710 --> 00:01:59,370
ou você tem que usar malloc para ter um comprimento flexível da matriz.

35
00:01:59,370 --> 00:02:03,680
Em listas ligadas é muito fácil, é só pegar mais elementos,

36
00:02:03,680 --> 00:02:07,210
colocar mais elementos na lista ligada ou remover elementos.

37
00:02:07,210 --> 00:02:09,370
E, na verdade, se você não quer que a lista ligada a serem classificados,

38
00:02:09,370 --> 00:02:13,950
você pode procurar e remover elementos em tempo constante,

39
00:02:13,950 --> 00:02:16,800
então O (1) tempo, por isso é muito conveniente.

40
00:02:16,800 --> 00:02:20,660
Você só tem que ter cuidado para se lembrar sempre de malloc e free os nós,

41
00:02:20,660 --> 00:02:25,510
apenas porque se você não fizer isso, você vai ter vazamentos de memória.

42
00:02:25,510 --> 00:02:31,480
Então listas ligadas - a definição de um nó é como o que nós temos aí.

43
00:02:31,480 --> 00:02:35,110
Eu coloquei int n, mas você pode armazenar todos os dados que você deseja.

44
00:02:35,110 --> 00:02:37,280
Então, se você deseja armazenar uma string, ela está bem.

45
00:02:37,280 --> 00:02:41,690
Se você deseja armazenar uma estrutura, está tudo bem, um duplo, o que quiser.

46
00:02:41,690 --> 00:02:44,630
Acabei de colocar int n para os exemplos aqui.

47
00:02:44,630 --> 00:02:46,800
E você tem um ponteiro para o próximo nó.

48
00:02:46,800 --> 00:02:51,940
Então, basicamente, uma lista ligada tem alguns dados, e, em seguida, ele aponta para o próximo nó.

49
00:02:51,940 --> 00:02:56,710
Se ele é o último elemento da lista ligada, ele vai apontar para NULL.

50
00:02:56,710 --> 00:02:59,060
Portanto, este é um exemplo de uma lista ligada.

51
00:02:59,250 --> 00:03:05,960
>> Ok, então agora vamos ver o que devemos fazer se eu quiser inserir um elemento em uma lista vinculada.

52
00:03:05,960 --> 00:03:08,810
Em primeiro lugar, uma inserção de função será do tipo void

53
00:03:08,810 --> 00:03:11,350
porque eu não quero retornar nada.

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

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

56
00:03:17,090 --> 00:03:21,840
Então, qual é a primeira coisa que devo fazer? Bem, eu deveria malloc em newNode,

57
00:03:21,840 --> 00:03:24,240
de modo que é a primeira linha.

58
00:03:24,240 --> 00:03:27,580
Estou apenas a criação de um novo nó para colocar em uma lista encadeada.

59
00:03:27,580 --> 00:03:32,360
Então o que eu posso fazer? Bem, sabemos que em nossas implementações de listas ligadas

60
00:03:32,360 --> 00:03:38,180
em sala de aula, colocamos sempre a cabeça como uma variável global.

61
00:03:38,180 --> 00:03:41,800
Então, o que podemos fazer é mudar a cabeça.

62
00:03:41,800 --> 00:03:44,300
Eu posso fazer este novo nó ser o novo chefe,

63
00:03:44,300 --> 00:03:46,670
e ele vai apontar para a cabeça anterior.

64
00:03:46,670 --> 00:03:50,390
Como podemos fazer isso? A primeira coisa que eu tenho que fazer

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

66
00:03:54,770 --> 00:03:57,530
que foi passado para a função.

67
00:03:57,530 --> 00:04:01,050
Então newNode é o próximo vai ser o cabeça.

68
00:04:01,050 --> 00:04:05,800
A cabeça vai ser newNode. Por isso, é muito simples.

69
00:04:05,800 --> 00:04:10,090
Para excluir um nó, nós podemos fazê-lo como -

70
00:04:10,090 --> 00:04:14,790
Uma maneira que nós poderíamos fazer isto é,

71
00:04:14,790 --> 00:04:18,160
Tudo bem, se eu queria excluir, por exemplo, 3,

72
00:04:18,160 --> 00:04:24,850
o que eu poderia fazer é apenas apontar o nó anterior

73
00:04:24,850 --> 00:04:27,580
para o próximo nó de 3.

74
00:04:27,580 --> 00:04:29,400
Então, eu só iria fazer algo assim.

75
00:04:29,400 --> 00:04:33,400
Mas qual é o problema em fazer isso?

76
00:04:33,400 --> 00:04:37,400
Eu tenho um vazamento de memória, então eu não tenho acesso ao número 3 mais.

77
00:04:37,400 --> 00:04:42,480
O problema com isso é que eu não vou ser capaz de libertar aquele nó.

78
00:04:42,480 --> 00:04:45,360
Eu vou ter de vazamento de memória e (ininteligível) vai me odiar.

79
00:04:45,360 --> 00:04:49,370
Então, ao invés de fazer isso, eu provavelmente deveria ter um ponteiro temporário.

80
00:04:49,370 --> 00:04:53,210
Então eu coloquei temporária. Ele vai apontar para o nó que deseja excluir.

81
00:04:53,210 --> 00:04:58,170
E então eu posso mover os nós anteriores para apontar para o próximo nó

82
00:04:58,170 --> 00:05:00,390
do nó que deseja excluir.

83
00:05:00,390 --> 00:05:02,730
E, finalmente, eu posso liberar o ponteiro.

84
00:05:02,730 --> 00:05:07,480
Eu tenho que liberar o ponteiro que eu criei ali?

85
00:05:07,480 --> 00:05:09,560
Eu não tenho que, só porque -

86
00:05:09,560 --> 00:05:13,430
a diferença é que este nó foi criada usando malloc,

87
00:05:13,430 --> 00:05:17,280
por isso é na pilha, enquanto que este foi apenas declarado como um interruptor de NULL na pilha.

88
00:05:17,280 --> 00:05:20,000
Então, eu não tenho para libertá-la.

89
00:05:20,000 --> 00:05:22,030
>> Okay. Então, agora vamos falar sobre pilhas.

90
00:05:22,030 --> 00:05:24,680
As pilhas são bastante simples.

91
00:05:24,680 --> 00:05:29,540
Fizemos pilhas e filas na sala de aula apenas usando matrizes,

92
00:05:29,540 --> 00:05:32,820
mas você deve ser familiar - basta estar ciente

93
00:05:32,820 --> 00:05:40,740
que você também pode fazer pilhas em filas usando listas ligadas também.

94
00:05:40,740 --> 00:05:44,460
Então se você tem uma matriz, o que seria uma pilha?

95
00:05:44,460 --> 00:05:46,810
Uma pilha de, por um lado, terá de ter um tamanho.

96
00:05:46,810 --> 00:05:49,950
Você tem que armazenar o que é o tamanho da pilha que você tem agora.

97
00:05:49,950 --> 00:05:52,980
E também você teria um array, neste caso dos números,

98
00:05:52,980 --> 00:05:55,120
mas se você quiser, pode ser um array

99
00:05:55,120 --> 00:06:00,380
de cordas, uma matriz de struct, qualquer coisa que você deseja armazenar.

100
00:06:00,380 --> 00:06:03,240
Sobre a pilha: A diferença entre uma pilha e uma lista ligada

101
00:06:03,240 --> 00:06:08,590
é que na pilha só tem acesso ao elemento, que foi colocado na pilha.

102
00:06:08,590 --> 00:06:11,770
Chama-se em último lugar, primeiro a sair.

103
00:06:11,770 --> 00:06:15,090
Assim como você tem uma pilha de bandejas,

104
00:06:15,090 --> 00:06:17,670
se você colocar uma bandeja em cima da pilha,

105
00:06:17,670 --> 00:06:22,670
você tem que remover a bandeja primeiro a ter acesso às outras bandejas.

106
00:06:22,670 --> 00:06:26,310
É a mesma coisa com stacks.

107
00:06:26,310 --> 00:06:31,220
Então, se eu quiser, por exemplo, adicionar um elemento a uma pilha, o que devo fazer?

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

109
00:06:34,070 --> 00:06:37,130
A primeira coisa que você tem a fazer é verificar se o tamanho da pilha

110
00:06:37,130 --> 00:06:40,150
não é maior ou igual à capacidade da pilha.

111
00:06:40,150 --> 00:06:45,810
Porque se você já estiver em plena capacidade, você não pode adicionar qualquer outra coisa.

112
00:06:45,810 --> 00:06:51,140
E, em seguida, se não, você só tem que adicionar o elemento à pilha.

113
00:06:51,140 --> 00:06:54,530
E, finalmente, incrementar o tamanho. Por isso, é bastante simples.

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

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

116
00:07:00,350 --> 00:07:03,870
o último elemento que foi adicionado e retornar o valor do elemento,

117
00:07:03,870 --> 00:07:09,180
a primeira coisa que tem que verificar é que a pilha não está vazia.

118
00:07:09,180 --> 00:07:11,510
Porque se ele está vazio, não posso retornar nada.

119
00:07:11,510 --> 00:07:14,820
Nesse caso, estou retornando -1.

120
00:07:14,820 --> 00:07:18,960
Caso contrário, eu vou diminuir o tamanho da especificação,

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

122
00:07:22,510 --> 00:07:27,230
Por que eu diminuir o tamanho e, em seguida, retornar s.size?

123
00:07:27,230 --> 00:07:30,930
É porque, neste caso, a especificação tem tamanho 4,

124
00:07:30,930 --> 00:07:33,810
e eu quero devolver o quarto elemento, certo?

125
00:07:33,810 --> 00:07:36,030
Mas o que é o índice do quarto elemento? Três.

126
00:07:36,030 --> 00:07:44,510
Desde que eu size - vai ser 3, eu só posso retornar s.numbers (s.size)

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

128
00:07:48,410 --> 00:07:50,380
Agora >> filas. As filas são praticamente a mesma coisa.

129
00:07:50,380 --> 00:07:54,950
A única diferença é que em vez de ter passado in, first out,

130
00:07:54,950 --> 00:07:57,480
você tem first in, first out.

131
00:07:57,480 --> 00:07:59,460
Provavelmente, se você está esperando para ir a um concerto,

132
00:07:59,460 --> 00:08:04,260
você não seria feliz se você tivesse uma pilha ao invés de uma fila.

133
00:08:04,260 --> 00:08:07,730
Sendo a última pessoa a entrar seria a primeira pessoa a entrar no show.

134
00:08:07,730 --> 00:08:09,760
Você provavelmente não seria feliz.

135
00:08:09,760 --> 00:08:15,020
Na fila, a primeira pessoa a entrar é também a primeira pessoa a sair.

136
00:08:15,020 --> 00:08:18,720
Assim, na definição de uma fila de, além de ter o tamanho da matriz,

137
00:08:18,720 --> 00:08:23,360
você também tem que ter a cabeça, que é o índice para o chefe da pilha.

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

139
00:08:29,000 --> 00:08:32,710
Enqueue é a mesma coisa que o impulso para stacks.

140
00:08:32,710 --> 00:08:34,980
Se você fosse muito ingênuo, você teria apenas que dizer:

141
00:08:34,980 --> 00:08:39,289
bem, eu só posso fazer exatamente a mesma coisa que eu fiz por impulso.

142
00:08:39,289 --> 00:08:44,030
Eu posso apenas verificar se não é além da capacidade.

143
00:08:44,030 --> 00:08:48,760
Se for, eu return false, caso contrário, eu só posso exportar o novo valor

144
00:08:48,760 --> 00:08:50,630
e, em seguida, aumentar o tamanho.

145
00:08:50,630 --> 00:08:52,750
Mas por que isso é errado?

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

147
00:08:55,010 --> 00:08:57,020
Estou tentando enfileirar um monte de coisas,

148
00:08:57,020 --> 00:08:58,390
e então eu vou para retirar da fila e enfileirar.

149
00:08:58,390 --> 00:09:00,550
Há um monte de comandos, mas é muito simples.

150
00:09:00,550 --> 00:09:04,790
Eu vou enfileirar 5, então adicionar 5 e 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, e então eu quero desenfileirar alguma coisa,

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

153
00:09:12,000 --> 00:09:14,640
Então, eu estou indo para remover o número 3, certo?

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

155
00:09:17,320 --> 00:09:21,450
Agora, se eu tentar enfileirar outra coisa, o que vai acontecer?

156
00:09:21,450 --> 00:09:24,290
De acordo com a minha implementação,

157
00:09:24,290 --> 00:09:31,040
Eu ia colocar o próximo número na q.size índice.

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

159
00:09:35,140 --> 00:09:38,640
de modo que o índice de 8 estará aqui na última posição.

160
00:09:38,640 --> 00:09:43,900
Se eu tentar enfileirar um aqui, eu estaria substituindo a última posição

161
00:09:43,900 --> 00:09:45,870
para o número 1, o qual é completamente errado.

162
00:09:45,870 --> 00:09:49,870
O que eu quero fazer é embrulhar ao redor e ir para a primeira posição.

163
00:09:49,870 --> 00:09:52,870
Talvez você gostaria apenas de dizer, bem, eu só tenho que verificar

164
00:09:52,870 --> 00:09:55,600
se eu realmente pode colocar alguma coisa lá.

165
00:09:55,600 --> 00:09:58,560
Se não, eu acabei de dizer, oh, a nova capacidade total

166
00:09:58,560 --> 00:10:02,010
é realmente capacidade - 1, e você não pode colocar um elemento lá.

167
00:10:02,010 --> 00:10:06,150
Mas qual é o problema? O problema é que se eu apenas desenfileirar tudo aqui

168
00:10:06,150 --> 00:10:08,240
e depois eu tento acrescentar algo mais, seria apenas dizer:

169
00:10:08,240 --> 00:10:11,210
bem, você estava em plena capacidade, que é 0.

170
00:10:11,210 --> 00:10:13,620
Assim, a fila está desaparecido.

171
00:10:13,620 --> 00:10:16,990
Você tem que envolver em torno, e uma maneira de envolver em torno de

172
00:10:16,990 --> 00:10:22,040
que vocês aprenderam em Série de Exercícios visionários e outros estava usando mod.

173
00:10:22,040 --> 00:10:29,090
Você pode experimentá-lo em casa para entender por que você faria q.size + q.head

174
00:10:29,090 --> 00:10:31,080
capacidade de modificação, mas se você verificar aqui,

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

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

177
00:10:37,760 --> 00:10:47,590
e a cabeça foi de 1, porque foi aqui esta posição da matriz.

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

179
00:10:51,970 --> 00:10:56,640
Ele iria para o índice 0. Nós vamos estar na posição certa.

180
00:10:56,640 --> 00:10:59,750
E, em seguida, tentar a fila em casa.

181
00:10:59,750 --> 00:11:04,950
Algumas coisas importantes: tente entender a diferença entre uma pilha e uma fila.

182
00:11:04,950 --> 00:11:11,620
Em casa, para tentar obter muito familiarizado com a implementação de enfileiramento, dequeue, push e pop.

183
00:11:11,620 --> 00:11:16,560
E também entendo quando você usaria cada uma delas.

184
00:11:16,560 --> 00:11:22,830
>> Então vamos relaxar por 10 segundos, com um monte de Pokémons.

185
00:11:22,830 --> 00:11:26,080
E agora vamos voltar para estruturas de dados.

186
00:11:26,080 --> 00:11:29,770
Hash tabelas. Muitas pessoas estavam com medo de tabelas de hash.

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

188
00:11:33,650 --> 00:11:35,980
As tabelas de hash e tentativas, muitas pessoas ficam com medo deles.

189
00:11:35,980 --> 00:11:38,540
Eles pensam que é tão difícil de entender. Sim?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Problema jogo 5. Problema >> ajuste 5, sim. Graças Rob.

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

192
00:11:43,370 --> 00:11:49,340
Problema jogo 5 foi Ortográfico, e você tinha que usar uma tabela hash ou uma tentativa.

193
00:11:49,340 --> 00:11:55,360
Muita gente pensou que eles eram super difícil de entender, mas eles são realmente muito simples.

194
00:11:55,360 --> 00:12:01,290
O que é uma tabela hash, basicamente? Uma tabela é um conjunto de listas ligadas.

195
00:12:01,290 --> 00:12:06,730
A única diferença entre uma matriz e uma tabela hash

196
00:12:06,730 --> 00:12:09,730
é que na tabela de hash que você tem algo chamado de função hash.

197
00:12:09,730 --> 00:12:12,080
O que é uma função hash?

198
00:12:12,080 --> 00:12:13,970
Eu não sei se vocês podem ler aqui.

199
00:12:13,970 --> 00:12:16,090
Este é um exemplo de uma tabela de hash.

200
00:12:16,090 --> 00:12:19,220
Assim, você pode ver que você tem uma matriz com 31 elementos.

201
00:12:19,220 --> 00:12:22,440
E o que fazemos em uma tabela hash é ter uma função hash

202
00:12:22,440 --> 00:12:26,660
que vai traduzir uma chave, cada um int para um índice.

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

204
00:12:31,740 --> 00:12:34,190
Gostaria de colocar B. Harrison em minhas funções de hash,

205
00:12:34,190 --> 00:12:36,960
ea função de hash retornaria 24.

206
00:12:36,960 --> 00:12:40,930
Então eu sei que eu quero armazenar B. Harrison em 24.

207
00:12:40,930 --> 00:12:46,580
Então essa é a diferença entre ter apenas uma matriz e ter uma tabela hash.

208
00:12:46,580 --> 00:12:48,740
Na tabela hash você terá uma função que vai dizer

209
00:12:48,740 --> 00:12:54,740
onde armazenar os dados que você deseja armazenar.

210
00:12:54,740 --> 00:12:57,040
Para a função de hash, você quer olhar para uma função hash

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

212
00:13:00,600 --> 00:13:07,810
Como você pode ver aqui, você vê que uma grande quantidade de dados que eu queria loja era na verdade 19

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

214
00:13:12,470 --> 00:13:16,920
Assim, a função de hash que eu usei não era muito bem distribuído.

215
00:13:16,920 --> 00:13:20,710
Quando dizemos bem distribuída, isso significa que queremos ter,

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

217
00:13:26,520 --> 00:13:32,190
como, uma diferença de 1 ou 2 para cada um dos índices nas matrizes.

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

219
00:13:43,950 --> 00:13:48,600
E é fácil de verificar se é válido na tabela de hash, ver como tabelas de hash.

220
00:13:48,600 --> 00:13:51,770
>> Então árvores. Esta é uma árvore.

221
00:13:51,770 --> 00:13:56,400
Árvores em ciência da computação estão de cabeça para baixo por algum motivo.

222
00:13:56,400 --> 00:14:00,150
Então, aqui você tem a raiz da árvore e, em seguida, as folhas.

223
00:14:00,150 --> 00:14:05,630
Você deve apenas saber a nomenclatura para os pais ea criança.

224
00:14:05,630 --> 00:14:12,880
Cada nó tem os seus filhos, que são os nós que estão abaixo do pai.

225
00:14:12,880 --> 00:14:19,660
Assim, por exemplo, 2, vai ser o pai para 3 e para a outra criança ali mesmo,

226
00:14:19,660 --> 00:14:25,290
enquanto 3 vai ser o pai de uma e as outras crianças que estão lá.

227
00:14:25,290 --> 00:14:29,990
E um vai ser 3 da criança, e assim por diante.

228
00:14:29,990 --> 00:14:34,610
Temos algo muito mais interessante, chamado de uma árvore de busca binária,

229
00:14:34,610 --> 00:14:39,040
em que todos os valores do lado direito de um nó

230
00:14:39,040 --> 00:14:41,660
vão estar à direita, aqui - na direita,

231
00:14:41,660 --> 00:14:46,780
vai ser maior do que o elemento da raiz.

232
00:14:46,780 --> 00:14:49,780
Então, se eu tenho o número 5 aqui, todos os elementos à direita

233
00:14:49,780 --> 00:14:51,940
vai ser maior que 5, e no lado esquerdo

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

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

236
00:14:58,780 --> 00:15:01,660
Bem, se eu quiser verificar se o número 7 está aqui, por exemplo,

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

238
00:15:05,960 --> 00:15:09,540
É maior, então eu sei que vai ter que ser no lado direito da árvore.

239
00:15:09,540 --> 00:15:13,980
Então, eu tenho muito menos coisas para olhar.

240
00:15:13,980 --> 00:15:19,520
Na implementação de uma árvore de busca binária, o nó, eu só vou ter que ter dados,

241
00:15:19,520 --> 00:15:21,750
assim int n; você também pode ter uma string

242
00:15:21,750 --> 00:15:23,630
ou qualquer coisa que você queria.

243
00:15:23,630 --> 00:15:28,100
Você só tem que ter cuidado em definir o que é maior, o que for menor.

244
00:15:28,100 --> 00:15:30,390
Então se você tivesse cordas, por exemplo, você pode definir

245
00:15:30,390 --> 00:15:34,690
que todas essas coisas à direita vai ter comprimento maior,

246
00:15:34,690 --> 00:15:40,940
a esquerda vai ter comprimentos menores, por isso é realmente até você.

247
00:15:40,940 --> 00:15:44,930
>> Como posso implementar para encontrar BST?

248
00:15:44,930 --> 00:15:47,840
A primeira coisa que você tem a fazer é verificar se a raiz é NULL.

249
00:15:47,840 --> 00:15:50,920
Se for NULL, significa que a coisa não está lá

250
00:15:50,920 --> 00:15:53,330
porque você não tem sequer uma árvore, certo?

251
00:15:53,330 --> 00:15:55,790
Então eu retornar false.

252
00:15:55,790 --> 00:15:58,740
Caso contrário, eu vou verificar se o número é maior

253
00:15:58,740 --> 00:16:01,720
do que o valor da raiz.

254
00:16:01,720 --> 00:16:04,250
Vou tentar encontrar o elemento à direita

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

256
00:16:08,590 --> 00:16:11,310
Você vê que eu estou usando recursão aqui.

257
00:16:11,310 --> 00:16:14,150
E então se for menos, eu vou olhar para a esquerda.

258
00:16:14,150 --> 00:16:18,330
E, finalmente, de outra forma, se não é menos ou não maior,

259
00:16:18,330 --> 00:16:20,660
isso significa que ele é o próprio valor.

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

261
00:16:23,010 --> 00:16:26,360
Você pode ver aqui que eu usei, se, se, se.

262
00:16:26,360 --> 00:16:30,820
E lembre-se, no questionário 0, tivemos um problema que tinha, se, se, se,

263
00:16:30,820 --> 00:16:32,780
e você deveria encontrar a ineficiência,

264
00:16:32,780 --> 00:16:35,180
ea ineficiência foi que você usou se.

265
00:16:35,180 --> 00:16:39,060
Você deveria ter usado se, else if, else if e else.

266
00:16:39,060 --> 00:16:44,240
Então, eu deveria usar else if e else if e else aqui?

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

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

269
00:16:51,140 --> 00:16:53,480
É ótimo. Então, ela está dizendo que não importa,

270
00:16:53,480 --> 00:16:55,930
só porque a ineficiência que tínhamos antes

271
00:16:55,930 --> 00:16:59,550
foi que, porque, talvez, se alguma condição foi satisfeita,

272
00:16:59,550 --> 00:17:03,570
para que você tenha realizado uma ação, mas então você ia verificar todas as outras condições.

273
00:17:03,570 --> 00:17:06,319
Mas, neste caso, ele retornou de imediato, por isso não importa.

274
00:17:06,319 --> 00:17:09,220
Então você não tem que usar else if.

275
00:17:09,220 --> 00:17:11,740
>> E, finalmente, vamos falar de tentativas,

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

277
00:17:13,800 --> 00:17:15,980
A tentativa é uma árvore de matrizes.

278
00:17:15,980 --> 00:17:20,369
É muito rápido para procurar valores, mas usa muita memória.

279
00:17:20,369 --> 00:17:22,530
E é, geralmente, para filtrar as palavras, então quando você

280
00:17:22,530 --> 00:17:27,920
pretende implementar, por exemplo, eu não sei, como um livro de telefone em seu telefone

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

282
00:17:30,440 --> 00:17:32,510
e só tem nomes de pessoas que têm B.

283
00:17:32,510 --> 00:17:37,960
É muito fácil de implementar que o uso de uma tentativa, por exemplo.

284
00:17:37,960 --> 00:17:39,820
Como você define um nó em uma tentativa?

285
00:17:39,820 --> 00:17:43,910
Você apenas tem que ter um bool que vai ser is_word.

286
00:17:43,910 --> 00:17:48,660
Isso representa que a utilização de todos os personagens antes que o nó,

287
00:17:48,660 --> 00:17:51,920
que foram capazes de formar uma palavra,

288
00:17:51,920 --> 00:17:57,230
e então você vai ter uma matriz de ponteiros para os nós.

289
00:17:57,230 --> 00:18:03,120
Você pode ver que temos um conjunto de nós pai, então nó * array? Sim?

290
00:18:03,120 --> 00:18:06,050
Então, vamos ver como isso vai funcionar. Para a verificação ortográfica,

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

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

293
00:18:12,150 --> 00:18:17,800
Antes aqui eu só vou usar 2, porque eu quero ser capaz de escrever no quadro.

294
00:18:17,800 --> 00:18:20,230
Okay. Portanto, este é um exemplo de uma tentativa.

295
00:18:20,230 --> 00:18:25,600
Se eu definir o primeiro nó, eu vou ter uma matriz de dois elementos

296
00:18:25,600 --> 00:18:29,290
que são dois ponteiros para NULL, então eu só colocar 'a' e 'b'.

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

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

299
00:18:34,420 --> 00:18:37,370
apenas porque, antes de que você não tem quaisquer caracteres.

300
00:18:37,370 --> 00:18:40,900
Assim, uma palavra vazia não é uma palavra. Portanto, é falsa.

301
00:18:40,900 --> 00:18:46,320
Se eu quiser adicionar 'a' para este dicionário, o que eu tenho que fazer?

302
00:18:46,320 --> 00:18:49,760
Eu teria apenas que malloc um novo nó para 'a',

303
00:18:49,760 --> 00:18:54,630
e, em seguida, adicionar a sua palavra como verdadeira.

304
00:18:54,630 --> 00:19:00,180
Por isso, apenas representa que ter 'a' vai ser verdade. Faz sentido?

305
00:19:00,180 --> 00:19:04,120
Então, se eu quiser adicionar 'ba', eu vou ter que malloc 1 para 'b',

306
00:19:04,120 --> 00:19:07,550
e então eu vou para configurar o boolean como false,

307
00:19:07,550 --> 00:19:10,160
porque 'b', por si só não é uma palavra.

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

309
00:19:13,010 --> 00:19:16,290
e então eu vou montar é uma palavra de verdade.

310
00:19:16,290 --> 00:19:18,950
Porque 'ba' é uma palavra.

311
00:19:18,950 --> 00:19:21,910
E então, se eu quero ver se 'b' é neste dicionário,

312
00:19:21,910 --> 00:19:26,730
Eu posso ir para o primeiro, 'b'. Eu descer, e eu olhar é palavra, e ela diz que falsa.

313
00:19:26,730 --> 00:19:30,110
Portanto, não é uma palavra. Se eu quiser conferir 'ba',

314
00:19:30,110 --> 00:19:38,010
Eu vou para o primeiro, 'b', e em seguida ir para 'a', e eu vejo verdade, por isso é uma palavra. Faz sentido?

315
00:19:38,010 --> 00:19:41,950
Muitas pessoas ficam confusas com tentativas. Não?

316
00:19:41,950 --> 00:19:44,740
>> Finalmente, codificação Huffman. Codificação de Huffman é muito útil

317
00:19:44,740 --> 00:19:47,550
para economizar memória e comprimir arquivos de texto,

318
00:19:47,550 --> 00:19:52,270
só porque um monte de vezes que você usa 'a' e 'e', ​​por exemplo,

319
00:19:52,270 --> 00:19:57,710
em seus documentos, mas eu não sei se vocês usam 'q' ou 'z' tanto.

320
00:19:57,710 --> 00:20:02,040
Tendo apenas 1 byte para cada personagem,

321
00:20:02,040 --> 00:20:08,520
cada - os 256 caracteres que temos na tabela ASCII não é muito melhor,

322
00:20:08,520 --> 00:20:11,410
só porque existem alguns personagens que você usa muito mais,

323
00:20:11,410 --> 00:20:15,180
então você provavelmente deve usar menos memória para aqueles.

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

325
00:20:17,560 --> 00:20:20,010
Temos que fazer uma árvore de Huffman.

326
00:20:20,010 --> 00:20:23,370
 Uma árvore de Huffman tem nós

327
00:20:23,370 --> 00:20:27,760
que tem um símbolo que vai ser como, 'a', 'b', 'c', a carta,

328
00:20:27,760 --> 00:20:32,990
a letra que você tem, uma freqüência que é a freqüência com que a palavra aparece no texto,

329
00:20:32,990 --> 00:20:36,280
que você estava criando a árvore de Huffman para,

330
00:20:36,280 --> 00:20:41,800
e, em seguida, um nó que vai para apontar para a esquerda da árvore Huffman

331
00:20:41,800 --> 00:20:47,210
e outro nó que vai apontar para a direita. Assim como uma árvore.

332
00:20:47,210 --> 00:20:49,440
Como você constrói uma árvore de Huffman?

333
00:20:49,440 --> 00:20:54,020
Você vai escolher os dois nós que têm as freqüências mais baixas.

334
00:20:54,020 --> 00:20:56,490
Se você tem um laço que vai escolher os 2 nós

335
00:20:56,490 --> 00:20:59,870
que têm os valores mais baixos, bem ASCII.

336
00:20:59,870 --> 00:21:02,420
Em seguida, você vai criar uma nova árvore fora dessas 2 nós

337
00:21:02,420 --> 00:21:08,030
que vai ter a frequência combinados no nó pai.

338
00:21:08,030 --> 00:21:13,240
E então você está indo para remover os dois filhos da floresta

339
00:21:13,240 --> 00:21:15,570
e substituí-los com o pai.

340
00:21:15,570 --> 00:21:18,930
E você vai repetir isso até que você só tem uma árvore na floresta.

341
00:21:18,930 --> 00:21:23,840
Então, vamos ver como você faria uma árvore Huffman para ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Você pode ver aqui que todas as cartas têm freqüência 1, exceto para 'A'; que tem freqüência 2.

343
00:21:29,220 --> 00:21:34,090
Então, eu criei nós para todas as letras que eu coloquei em ordem de valor ASCII e frequência.

344
00:21:34,090 --> 00:21:40,090
Então, se eu quiser criar a primeira árvore, será com 'L' e 'M'.

345
00:21:40,090 --> 00:21:43,100
Então é aqui. A freqüência do par será 2

346
00:21:43,100 --> 00:21:49,470
porque é 1 + 1, então o próximo 2 com as freqüências mais baixas são 'Y' e 'Z'.

347
00:21:49,470 --> 00:21:53,180
E então eu tenho todos eles ser - têm uma frequência de 2.

348
00:21:53,180 --> 00:22:00,470
Então, quais são os que têm o valor ASCII menor para o próximo?

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

350
00:22:04,830 --> 00:22:09,930
e, por fim, é 4 e 2, então 2 vai ser do lado esquerdo.

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

352
00:22:12,430 --> 00:22:16,060
Então, se eu quero escrever algum texto,

353
00:22:16,060 --> 00:22:24,440
como em binário para converter em texto, usando a árvore de Huffman é muito fácil.

354
00:22:24,440 --> 00:22:30,220
Por exemplo, se eu digo que a mudança para a esquerda é a 0 e se movendo para a direita é um 1,

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

356
00:22:32,410 --> 00:22:35,530
Assim como 1, 1, portanto, direita, direita,

357
00:22:35,530 --> 00:22:40,370
e, em seguida, 0, de modo que seria deixado G, e, em seguida, 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Então, 1, 0, assim apenas 1, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
E, em seguida, 0, 1, de modo que "Z".

360
00:22:47,540 --> 00:22:52,170
E, em seguida, 1, 0, 0 - nenhum.

361
00:22:52,170 --> 00:22:56,780
0, 0 será 'Y', de modo preguiçoso.

362
00:22:56,780 --> 00:23:06,060
Então, isso é tudo para mim, Rob vai assumir.

363
00:23:06,060 --> 00:23:08,400
>> [Rob Bowden] Assim, a semana 7 coisas.

364
00:23:08,400 --> 00:23:11,390
Temos muito a passar por cima muito rápido.

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

366
00:23:13,430 --> 00:23:16,760
Biblioteca CS50, em seguida, HTML, HTTP, CSS.

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

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

369
00:23:24,330 --> 00:23:31,200
Bit a bit e, bit a bit OR, XOR, deslocamento à esquerda, deslocamento para a direita, e não.

370
00:23:31,200 --> 00:23:35,420
Direito mudar e não você mal viu em palestra em tudo.

371
00:23:35,420 --> 00:23:40,480
Nós vamos passar por isso rapidamente aqui, mas é bom saber que estes são os 6 que existe.

372
00:23:40,480 --> 00:23:45,070
Lembre-se que os operadores bit a bit é como quando você faz 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Você não está lidando com o binário de 3 e 4.

374
00:23:49,420 --> 00:23:56,550
Com operadores bit a bit na verdade você está lidando com os bits individuais dos números 3 e 4.

375
00:23:56,550 --> 00:23:59,120
>> Então, o primeiro que vamos dizer é bit a bit não,

376
00:23:59,120 --> 00:24:02,340
e tudo que faz é inverter todos os bits.

377
00:24:02,340 --> 00:24:05,500
Então, aqui, se você está escrevendo isso em C, você não escrevê-lo

378
00:24:05,500 --> 00:24:09,380
como ~ 11011 ou qualquer outra coisa, você poderia escrevê-lo como ~ 4,

379
00:24:09,380 --> 00:24:12,970
e, em seguida, ele iria virar a representação binária de 4.

380
00:24:12,970 --> 00:24:24,800
Então, aqui, ~ de um número binário 1101101 vai virar exatamente todos os 1 do que 0 e todos os 0 de 1 de.

381
00:24:24,800 --> 00:24:27,600
Como eu disse lá, o uso freqüente desta,

382
00:24:27,600 --> 00:24:30,830
e nós vamos vê-lo em um pouco, é como nós queremos chegar a algum número

383
00:24:30,830 --> 00:24:35,460
onde todos os bits são 1, com exceção de um deles.

384
00:24:35,460 --> 00:24:38,560
Por isso, é geralmente mais fácil de expressar o número

385
00:24:38,560 --> 00:24:40,630
onde apenas aquele único bit é definido,

386
00:24:40,630 --> 00:24:44,650
e, em seguida, tomar o ~ dele, então todos os outros bit é definido, exceto por isso.

387
00:24:44,650 --> 00:24:50,300
Então é isso que nós vamos usar mais um pouco.

388
00:24:50,300 --> 00:24:58,220
>> OR bit a bit. Aqui estão dois números binários, e esses 2 números

389
00:24:58,220 --> 00:25:00,780
são bastante representativo, uma vez que representam todas as possíveis

390
00:25:00,780 --> 00:25:07,290
combinação de bits que você precisa para operar.

391
00:25:07,290 --> 00:25:13,540
Aqui, quando eu clicaria cada bit, nós apenas estamos indo para comparar diretamente para baixo.

392
00:25:13,540 --> 00:25:15,410
Assim, no lado esquerdo, temos um 1 e um 1.

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

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

395
00:25:25,320 --> 00:25:27,840
Bit a bit 1 e 0, vai ser a mesma coisa, um.

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

397
00:25:31,880 --> 00:25:37,300
Assim, o único caso em que eu recebo 0 é no 0 | 0 caso.

398
00:25:37,300 --> 00:25:40,020
E você pode pensar que, assim como seus prefeitos lógicas.

399
00:25:40,020 --> 00:25:44,830
Então, se você pensar em 1 como verdadeiro e 0 como falso, a mesma coisa se aplica aqui.

400
00:25:44,830 --> 00:25:50,040
Tão verdadeiro ou verdadeiro é verdadeiro, verdadeiro ou falso é verdadeiro.

401
00:25:50,040 --> 00:25:57,150
Falso ou verdadeiro é verdadeiro, falso ou falso é a única coisa que é realmente falso.

402
00:25:57,150 --> 00:26:00,100
Aqui está o exemplo que você deve saber

403
00:26:00,100 --> 00:26:05,160
como um bom exemplo de quando operadores bit a bit são usados.

404
00:26:05,160 --> 00:26:08,660
Aqui se ou 'A' maiúsculo com OX20,

405
00:26:08,660 --> 00:26:11,830
e vamos olhar para isso em um segundo, temos alguma coisa.

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

407
00:26:16,020 --> 00:26:26,750
Então, vamos puxar para cima da tabela ASCII.

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

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

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

411
00:26:45,120 --> 00:26:48,280
Certeza que vimos em sala de aula. Eu acho que nós vimos em sala de aula

412
00:26:48,280 --> 00:26:52,730
que é muito fácil converter de hexadecimal para binário.

413
00:26:52,730 --> 00:26:55,280
Então, aqui, se eu quiser colocar 4 em binário,

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

415
00:26:59,550 --> 00:27:03,620
Este é um lugar de, lugar de 2, 4 do lugar, por isso este é 4.

416
00:27:03,620 --> 00:27:08,550
Então eu posso dividir 1 em binário, que vai ser 0001.

417
00:27:08,550 --> 00:27:14,280
E assim é que isto vai ser a representação de 'A' em binário.

418
00:27:14,280 --> 00:27:22,720
Levando em minúsculas 'a', é agora vai ser Ox61,

419
00:27:22,720 --> 00:27:27,050
onde, dividindo-se estes em seu binário, de modo a 6 -

420
00:27:27,050 --> 00:27:37,830
Vamos realmente fazê-lo - que não há borracha? Eraser.

421
00:27:37,830 --> 00:27:48,220
Ox61. Então, dividindo 6 em binário vai ser 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
E a divisão 1 vai ser 0001.

423
00:27:54,610 --> 00:27:56,520
Olhando para a diferença entre estes dois,

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

425
00:28:04,250 --> 00:28:11,810
Então, voltando para aqui - tudo bem.

426
00:28:11,810 --> 00:28:15,920
Voltando aqui, se olharmos para o que o bit é OX20,

427
00:28:15,920 --> 00:28:22,210
OX20 assim dividindo-se em seu binário,

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

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

430
00:28:33,470 --> 00:28:38,210
com a alternância entre capitais e minúsculas 'a'.

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

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

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

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

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

436
00:29:04,170 --> 00:29:08,780
Minúsculas um, porque só oring 'a' com OX20,

437
00:29:08,780 --> 00:29:14,580
Eu só vou ser oring este único bit para 1, que já está a 1, por isso não importa.

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

439
00:29:17,960 --> 00:29:24,820
>> Bit a bit e. Mais uma vez, podemos pensar nisso como nossa contrapartida lógica e.

440
00:29:24,820 --> 00:29:28,180
No lado esquerdo temos verdadeiro e fiel.

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

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

443
00:29:36,270 --> 00:29:38,550
nenhuma dessas coisas são verdadeiras.

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

445
00:29:44,170 --> 00:29:48,830
Então, agora, aqui, aqui é onde eu usei o bit a bit de confiança não,

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

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

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

449
00:29:59,570 --> 00:30:03,600
Isso vai inverter todos os bits.

450
00:30:03,600 --> 00:30:09,330
Então, eu tenho 1101, 1111.

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

452
00:30:18,940 --> 00:30:22,430
A única parte que realmente precisamos pensar é um presente,

453
00:30:22,430 --> 00:30:26,020
uma vez que, se todos esses bits são definidos a 1,

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

455
00:30:29,000 --> 00:30:31,260
exceto, talvez, o que isto é pouco.

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

457
00:30:34,460 --> 00:30:39,810
porque tudo o que isso é, anded com isso vai ser 0.

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

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

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

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

462
00:30:56,720 --> 00:30:59,570
Anding com este 0 vai torná-lo um 0,

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

464
00:31:02,530 --> 00:31:06,600
>> Ambos são 'A', e por último, mas não menos importante deste tipo,

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

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

467
00:31:14,400 --> 00:31:18,420
Este é parecido com o que você costuma pensar em como ou no mundo real.

468
00:31:18,420 --> 00:31:23,190
Então você quer 'x' ou 'y', mas não ambos.

469
00:31:23,190 --> 00:31:28,700
Aqui 1 ^ 1 vai ser 0.

470
00:31:28,700 --> 00:31:33,650
Porque a verdadeira, isto é - ele não funciona tão bem com o lógico verdadeiro e falso

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

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

473
00:31:40,100 --> 00:31:44,810
Porque nós só queremos retornar true se apenas um deles é verdadeiro.

474
00:31:44,810 --> 00:31:50,950
Assim, um ^ 1 é 0. E quanto a 0 ^ 1?

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

476
00:31:56,010 --> 00:32:03,890
Assim, em todas as circunstâncias, bit a bit 0 0 algo vai ser 0.

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

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

479
00:32:14,660 --> 00:32:20,850
E o único caso em que um bit a bit 1 não é um é com a exclusiva ou.

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

481
00:32:24,580 --> 00:32:36,520
Então, aqui, agora, usando XOR - então estamos de volta a 20.

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

483
00:32:43,480 --> 00:32:50,020
Assim, a 1 ^ 0 vai me dar uma coisa? A uma.

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

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

486
00:33:04,010 --> 00:33:09,310
Porque tudo o que isso está fazendo, este XORing com OX20

487
00:33:09,310 --> 00:33:15,380
é efetivamente lançando tudo o que este bit é.

488
00:33:15,380 --> 00:33:21,240
Se este for um 0, ele agora vai se tornar um 1.

489
00:33:21,240 --> 00:33:26,160
Uma vez que este é um 1, 1 ^ 1 é 0.

490
00:33:26,160 --> 00:33:33,280
Portanto, a nossa 'a' tornou-se 'A', e nossa 'A' tornou-se 'a'.

491
00:33:33,280 --> 00:33:36,910
Então XOR é uma maneira muito conveniente de apenas lançando o caso.

492
00:33:36,910 --> 00:33:39,960
Você só quer iterar sobre uma seqüência de letras

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

494
00:33:44,330 --> 00:33:50,680
você só XOR tudo com OX20.

495
00:33:50,680 --> 00:33:55,220
>> Agora nos resta turno. Deslocamento à esquerda é apenas vai, basicamente,

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

497
00:34:01,250 --> 00:34:05,550
Portanto, temos aqui 00001101.

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

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

500
00:34:13,580 --> 00:34:16,380
Em termos não binários,

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

502
00:34:24,699 --> 00:34:32,530
Então deslocamento à esquerda, vemos aqui, x << y é basicamente x * 2 ^ y.

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

504
00:34:40,139 --> 00:34:45,679
Se você só pensar em binário, em geral, como cada um dígito,

505
00:34:45,679 --> 00:34:49,530
se começarmos a partir da direita, é a 1 do lugar, então a 2 do lugar, então a 4 do lugar.

506
00:34:49,530 --> 00:34:51,330
Então, empurrando 0 do da direita,

507
00:34:51,330 --> 00:34:55,080
estamos apenas empurrando as coisas que estavam no 4 do lugar para o 8 de lugar,

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

509
00:34:57,920 --> 00:35:01,280
Cada turno apenas multiplica por 2. Sim?

510
00:35:01,280 --> 00:35:05,210
[Estudante] O que acontece se você desviado por 5?

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

512
00:35:10,790 --> 00:35:15,410
Inevitavelmente, é a mesma coisa. Como, inteiros são apenas 32 bits

513
00:35:15,410 --> 00:35:20,750
por isso, se você adicionar dois realmente grandes inteiros, ele simplesmente não se encaixa em um inteiro.

514
00:35:20,750 --> 00:35:23,660
Então, é a mesma coisa aqui. Se você trocou por 5,

515
00:35:23,660 --> 00:35:25,650
teríamos apenas perder essa.

516
00:35:25,650 --> 00:35:28,820
E isso é o tipo de coisa que eu quero dizer com "mais ou menos",

517
00:35:28,820 --> 00:35:37,470
onde se você mudar muito, você perde bits.

518
00:35:37,470 --> 00:35:39,830
>> Mudança direito vai ser o oposto,

519
00:35:39,830 --> 00:35:43,090
onde vamos enfiar 0 de fora da final,

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

521
00:35:48,400 --> 00:35:52,910
Então, fazendo isso, estamos basicamente reverter o que já tinha feito.

522
00:35:52,910 --> 00:35:57,780
E nós vemos que os três 0 na direita acabaram caído,

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

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

525
00:36:08,380 --> 00:36:11,200
Então, agora, aqui, é uma idéia similar.

526
00:36:11,200 --> 00:36:18,720
Por que é apenas cerca de x / 2 ^ y, e na verdade não x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
Porque se eu tinha mudado por 4, eu teria perdido a 1.

528
00:36:22,240 --> 00:36:25,950
Basicamente, o que você pensar, apenas pensar em divisão inteira em geral.

529
00:36:25,950 --> 00:36:31,070
Assim, como 5/2 é 2. Não é 2.5.

530
00:36:31,070 --> 00:36:35,000
É a mesma idéia aqui. Quando dividimos por 2,

531
00:36:35,000 --> 00:36:39,910
podemos perder pedaços estranhos ao longo do caminho.

532
00:36:39,910 --> 00:36:43,870
Então agora - é isso para bit a bit. Isso é tudo que você precisa saber.

533
00:36:43,870 --> 00:36:46,340
Lembre-se os casos de uso que vimos em sala de aula,

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

535
00:36:49,340 --> 00:36:53,220
ou você usá-los para máscaras de bits.

536
00:36:53,220 --> 00:36:58,620
As letras maiúsculas e minúsculas, conversões é um exemplo bastante protótipo.

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

538
00:37:01,640 --> 00:37:05,110
Alguém se lembra o que estava errado com esta função?

539
00:37:05,110 --> 00:37:10,140
Repare que nós declaramos um array de 12 bytes, 12 caracteres,

540
00:37:10,140 --> 00:37:18,510
e depois copiar para o nosso buffer de 12 caracteres de todo o bar string.

541
00:37:18,510 --> 00:37:25,080
Então, qual é o problema aqui?

542
00:37:25,080 --> 00:37:32,270
O número mágico 12 deve aparecer praticamente imediatamente como - por que 12?

543
00:37:32,270 --> 00:37:35,050
E se bar passa a ser mais de 12 caracteres?

544
00:37:35,050 --> 00:37:41,200
E se bar é milhões de personagens?

545
00:37:41,200 --> 00:37:46,010
Aqui a questão é memcpy. Se a barra é o suficiente,

546
00:37:46,010 --> 00:37:50,330
ela só vai completamente - 'c', 'c' não se importa que ele tinha apenas 12 caracteres;

547
00:37:50,330 --> 00:37:53,280
'C' não se importa que ele não pode caber que muitos bytes.

548
00:37:53,280 --> 00:37:58,250
Ele irá substituir apenas completamente char, os 12 bytes que já alocados para ele,

549
00:37:58,250 --> 00:38:01,830
e tudo passado, na memória que na verdade não pertencem a esse tampão

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

551
00:38:06,520 --> 00:38:09,780
Portanto, esta foi a imagem que vimos em sala de aula

552
00:38:09,780 --> 00:38:12,220
onde temos a nossa pilha crescendo.

553
00:38:12,220 --> 00:38:16,040
Você deve ser usado para estas imagens ou se familiarizar com eles novamente.

554
00:38:16,040 --> 00:38:21,260
Nós temos a nossa pilha crescendo, endereços de memória começam em 0 no topo

555
00:38:21,260 --> 00:38:26,270
e crescer até gosto 4 bilhões na parte inferior.

556
00:38:26,270 --> 00:38:28,820
Nós temos a nossa disposição 'c' em algum lugar na memória,

557
00:38:28,820 --> 00:38:32,260
então temos o nosso ponteiro para barrar direita por baixo,

558
00:38:32,260 --> 00:38:38,720
e então temos este ponteiro quadro salvos em nosso endereço de retorno e pilha da nossa rotina pai.

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

560
00:38:40,800 --> 00:38:45,360
É quando principal chama uma função foo, chama uma barra de funções,

561
00:38:45,360 --> 00:38:48,100
inevitavelmente, barrar retornos.

562
00:38:48,100 --> 00:38:52,610
Então, quando a barra de volta, eles precisam saber que ele vai voltar para a foo que o chamou.

563
00:38:52,610 --> 00:39:01,360
Assim, o endereço de retorno é o endereço da função que ele tem que voltar para quando a função retorna.

564
00:39:01,360 --> 00:39:05,830
A razão pela qual isso é importante para ataques de estouro de buffer é porque, convenientemente,

565
00:39:05,830 --> 00:39:09,580
hackers gostam de mudar o endereço de retorno.

566
00:39:09,580 --> 00:39:14,950
Em vez de voltar para foo, eu vou voltar para onde quer que o hacker quer que eu vá voltar.

567
00:39:14,950 --> 00:39:17,760
E, convenientemente, onde o hacker freqüentemente quer voltar para

568
00:39:17,760 --> 00:39:22,400
é o início do buffer que tinha originalmente.

569
00:39:22,400 --> 00:39:26,170
Então, observe, novamente, Little Indian.

570
00:39:26,170 --> 00:39:28,490
O aparelho é um exemplo de um sistema indiano pequeno,

571
00:39:28,490 --> 00:39:34,140
assim um número inteiro ou um ponteiro é armazenado com os bytes invertidos.

572
00:39:34,140 --> 00:39:38,980
Então, vamos ver - é isso? É.

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

574
00:39:45,660 --> 00:39:48,250
Lembre-se dos dígitos hexadecimais?

575
00:39:48,250 --> 00:39:50,640
Nós não inverter os dígitos hexadecimais em Little Indian,

576
00:39:50,640 --> 00:39:56,110
porque dois dígitos hexadecimais compõem um único byte, e inverter os bytes.

577
00:39:56,110 --> 00:40:00,300
É por isso que não armazenam, como, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Nós armazenar, em vez disso, cada par de dois dígitos, a partir da direita.

579
00:40:07,520 --> 00:40:10,880
Esse endereço refere-se ao endereço do início

580
00:40:10,880 --> 00:40:15,190
do nosso buffer que nós realmente queria copiar para, em primeiro lugar.

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

582
00:40:19,230 --> 00:40:24,100
aconteceu, em vez de ter uma sequência que era apenas

583
00:40:24,100 --> 00:40:27,060
uma seqüência de como inofensivo, o seu nome ou algo assim,

584
00:40:27,060 --> 00:40:33,900
E se, ao invés, essa seqüência foram apenas algumas de código arbitrário

585
00:40:33,900 --> 00:40:38,610
que fez tudo o que queria fazer?

586
00:40:38,610 --> 00:40:45,630
Assim, eles poderiam - Eu não posso pensar em nenhum código legal.

587
00:40:45,630 --> 00:40:47,780
Poderia ser qualquer coisa, no entanto. Qualquer código desastroso.

588
00:40:47,780 --> 00:40:51,440
Se eles quisessem, eles poderiam simplesmente fazer algo em falhas segmentos, mas isso seria inútil.

589
00:40:51,440 --> 00:40:54,950
Eles costumam fazer isso para invadir seu sistema.

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

591
00:40:59,930 --> 00:41:04,800
Isto é, basicamente, getInt, getString, todas essas funções que nós fornecemos para você.

592
00:41:04,800 --> 00:41:10,630
Portanto, temos de char string *, e essa é a abstração que surpreendeu

593
00:41:10,630 --> 00:41:12,450
em algum momento durante o semestre.

594
00:41:12,450 --> 00:41:18,220
Lembre-se que uma string é apenas um conjunto de caracteres.

595
00:41:18,220 --> 00:41:23,240
Então, vamos ver uma versão resumida do getString.

596
00:41:23,240 --> 00:41:25,920
Você deve olhar para trás, ele se lembrar de como ele é realmente implementado.

597
00:41:25,920 --> 00:41:30,950
Detalhes importantes são, observe que recebemos em um único caractere de cada vez

598
00:41:30,950 --> 00:41:34,570
de padrão em, que é como nós digitando no teclado.

599
00:41:34,570 --> 00:41:37,890
Assim, um único personagem de cada vez, e se conseguirmos muitos personagens,

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

601
00:41:40,580 --> 00:41:44,140
então precisamos aumentar a capacidade do nosso buffer.

602
00:41:44,140 --> 00:41:47,780
Então, aqui estamos dobrando o tamanho do nosso buffer.

603
00:41:47,780 --> 00:41:51,840
E isso continua acontecendo, nós inserir o caractere em nosso buffer

604
00:41:51,840 --> 00:41:56,220
até que recebamos uma nova linha ou fim de arquivo ou qualquer outra coisa,

605
00:41:56,220 --> 00:41:59,380
neste caso, estamos a fazer com a corda e, em seguida, o verdadeiro getString

606
00:41:59,380 --> 00:42:05,120
encolhe a memória, como se nós alocados muita memória ele vai voltar e encolher um pouco.

607
00:42:05,120 --> 00:42:08,830
Então, nós não mostram isso, mas a idéia principal é

608
00:42:08,830 --> 00:42:11,960
ele tem que ler em um único personagem de cada vez.

609
00:42:11,960 --> 00:42:17,140
Ele não pode simplesmente ler em uma coisa toda de uma vez,

610
00:42:17,140 --> 00:42:19,550
porque o seu tampão é apenas de um certo tamanho.

611
00:42:19,550 --> 00:42:26,590
Então, se a string que ele tenta inserir em buffer é muito grande, então seria transbordar.

612
00:42:26,590 --> 00:42:28,940
Então vamos evitar isso por apenas lendo em um único caractere

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

614
00:42:33,750 --> 00:42:40,270
Então getInt e as outras funções da biblioteca CS50 tendem a usar getString

615
00:42:40,270 --> 00:42:42,310
nas suas implementações.

616
00:42:42,310 --> 00:42:45,370
Então, eu destaquei as coisas importantes aqui.

617
00:42:45,370 --> 00:42:49,460
Ele chama getString para obter uma string.

618
00:42:49,460 --> 00:42:51,710
Se getString não conseguiu voltar para a memória,

619
00:42:51,710 --> 00:42:54,270
lembre-se que getString mallocs alguma coisa, então sempre que você chamar getString

620
00:42:54,270 --> 00:42:57,820
você não deve (ininteligível) grátis essa seqüência que você tem.

621
00:42:57,820 --> 00:43:02,870
Então, aqui, se ele não conseguiu malloc algo, voltamos INT_MAX como apenas uma bandeira que,

622
00:43:02,870 --> 00:43:05,650
hey, nós não estávamos realmente capaz de obter um número inteiro.

623
00:43:05,650 --> 00:43:10,830
Você deve ignorar o que eu voltar para você, ou

624
00:43:10,830 --> 00:43:15,540
você não deve tratar isso como uma entrada válida.

625
00:43:15,540 --> 00:43:21,360
Finalmente, assumindo que teve sucesso, nós usamos sscanf com essa bandeira especial,

626
00:43:21,360 --> 00:43:23,820
o que significa, em primeiro lugar corresponder a um número inteiro,

627
00:43:23,820 --> 00:43:26,770
então combinar quaisquer caracteres após esse inteiro.

628
00:43:26,770 --> 00:43:29,070
Então, observe que queremos igual a 1.

629
00:43:29,070 --> 00:43:32,940
Retornos Então sscanf quantos jogos se fez com sucesso?

630
00:43:32,940 --> 00:43:37,010
Ele irá retornar 1 se combinava com sucesso um número inteiro,

631
00:43:37,010 --> 00:43:40,890
ele irá retornar 0 se ele não corresponder a um número inteiro, e ele irá retornar 2

632
00:43:40,890 --> 00:43:45,920
se correspondesse um número inteiro seguido por algum personagem.

633
00:43:45,920 --> 00:43:49,780
Então, observe que tenta novamente se nós combinamos nada, mas 1.

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

635
00:43:55,230 --> 00:43:57,400
em seguida, 1, 2, 3 que são armazenados no número inteiro,

636
00:43:57,400 --> 00:43:59,620
X que ficam armazenados no personagem,

637
00:43:59,620 --> 00:44:06,410
sscanf voltaria 2, e gostaríamos de tentar novamente, porque nós só queremos um inteiro.

638
00:44:06,410 --> 00:44:09,810
>> Soprando rapidamente através de HTML, HTTP, CSS.

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

640
00:44:15,340 --> 00:44:19,960
Aqui está o exemplo de aula onde temos tags HTML.

641
00:44:19,960 --> 00:44:22,110
Temos tags de cabeça, marcas no corpo,

642
00:44:22,110 --> 00:44:27,770
temos exemplos de tags vazias onde nós realmente não têm um começo e perto tag,

643
00:44:27,770 --> 00:44:30,820
só temos link e imagem.

644
00:44:30,820 --> 00:44:38,480
Não há tag de imagem de fechamento; há apenas uma única marca que realiza tudo o que a etiqueta deve fazer.

645
00:44:38,480 --> 00:44:41,950
O link é um exemplo, nós vamos ver como você vincular a CSS,

646
00:44:41,950 --> 00:44:45,910
o roteiro é um exemplo de como você ligar para um JavaScript externo.

647
00:44:45,910 --> 00:44:53,100
É bastante simples, e lembre-se, HTML não é uma linguagem de programação.

648
00:44:53,100 --> 00:44:58,250
Aqui, me lembro como você definiria uma forma ou pelo menos o que isso faria?

649
00:44:58,250 --> 00:45:01,740
Essa forma tem uma ação e um método.

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

651
00:45:06,210 --> 00:45:09,040
Então GET é a versão em que a coisa é colocado na URL.

652
00:45:09,040 --> 00:45:11,680
POST é onde ele não é colocado na URL.

653
00:45:11,680 --> 00:45:18,520
Em vez disso, todos os dados do formulário é inserido mais escondido na solicitação HTTP.

654
00:45:18,520 --> 00:45:22,390
Então, aqui, a ação define onde a solicitação HTTP vai.

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

656
00:45:27,490 --> 00:45:32,890
Método. Lembre-se as diferenças entre GET e POST,

657
00:45:32,890 --> 00:45:37,200
e, diga apenas como um exemplo, se você deseja marcar alguma coisa.

658
00:45:37,200 --> 00:45:40,660
Você nunca será capaz de marcar um URL POST

659
00:45:40,660 --> 00:45:44,970
, porque os dados não são incluídos na URL.

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

661
00:45:49,790 --> 00:45:54,080
O Protocolo de Transferência de Hipertexto, você esperaria que transferir

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

663
00:45:57,710 --> 00:46:00,170
Mas também transfere todas as imagens que você encontra na Web,

664
00:46:00,170 --> 00:46:05,400
todos os downloads que você faz começar como uma solicitação HTTP.

665
00:46:05,400 --> 00:46:10,350
Então HTTP é apenas a linguagem da World Wide Web.

666
00:46:10,350 --> 00:46:15,610
E aqui é preciso reconhecer este tipo de uma solicitação HTTP.

667
00:46:15,610 --> 00:46:19,300
Aqui HTTP/1.1 no lado apenas diz que é a versão

668
00:46:19,300 --> 00:46:21,570
do protocolo que estou usando.

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

670
00:46:25,770 --> 00:46:30,110
Então nós vemos que isso era GET, a alternativa de ser POST, que você pode ver.

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

672
00:46:40,790 --> 00:46:44,240
Então lembre-se que este, o ponto de interrogação q = blá blá blá,

673
00:46:44,240 --> 00:46:49,040
é o tipo de material que é enviado por um formulário.

674
00:46:49,040 --> 00:46:51,830
A resposta que ele poderia voltar a me seria algo parecido com isso.

675
00:46:51,830 --> 00:46:54,050
Mais uma vez, começando com o protocolo, que vai ser isso,

676
00:46:54,050 --> 00:46:59,190
seguido pelo código de estado. Aqui é 200 OK.

677
00:46:59,190 --> 00:47:05,060
E, finalmente, a página da web que eu realmente pedi será seguido.

678
00:47:05,060 --> 00:47:08,210
A possível código de status que você pode ver, e você deve saber vários deles.

679
00:47:08,210 --> 00:47:12,770
200 OK, você provavelmente já viu antes.

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

681
00:47:17,830 --> 00:47:22,140
geralmente é se você vai a um site e algo está quebrado ou seus acidentes de código PHP,

682
00:47:22,140 --> 00:47:24,930
enquanto que no aparelho, temos que grande caixa de laranja

683
00:47:24,930 --> 00:47:27,830
que vem e diz, como, algo está errado, este código não funciona

684
00:47:27,830 --> 00:47:30,380
ou isso é ruim função.

685
00:47:30,380 --> 00:47:33,230
Normalmente sites não querem que você saiba quais as funções são realmente ruins,

686
00:47:33,230 --> 00:47:37,880
assim, em vez eles vão apenas dar-lhe 500 Internal Server Errors.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP é uma camada sob HTTP.

688
00:47:43,050 --> 00:47:47,550
Lembre-se que não há Internet fora da World Wide Web.

689
00:47:47,550 --> 00:47:52,270
Como se você jogar um jogo online que não passa por HTTP,

690
00:47:52,270 --> 00:47:55,740
ele está passando por um diferente - ele ainda está usando a Internet,

691
00:47:55,740 --> 00:47:58,900
mas ele não usa o HTTP.

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

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

694
00:48:07,820 --> 00:48:11,500
Cada computador tem um endereço IP, que são essas coisas de 4 dígitos

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

696
00:48:16,510 --> 00:48:23,390
Mas esse é o padrão de um endereço IP.

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

698
00:48:29,060 --> 00:48:33,410
isso é o que se traduz coisas como google.com para um endereço IP real.

699
00:48:33,410 --> 00:48:37,700
Então, se você digitar esse endereço IP em uma URL,

700
00:48:37,700 --> 00:48:40,850
que iria levá-lo para o Google, mas você tende a não se lembrar dessas coisas.

701
00:48:40,850 --> 00:48:45,470
Você tende a se lembrar google.com em seu lugar.

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

703
00:48:51,560 --> 00:48:54,880
TCP faz mais. Pense, como, você ter o seu navegador em execução web.

704
00:48:54,880 --> 00:48:58,670
Talvez você tenha algum aplicativo de e-mail está sendo executado;

705
00:48:58,670 --> 00:49:02,150
talvez você tem algum outro programa que utiliza a Internet em funcionamento.

706
00:49:02,150 --> 00:49:05,090
Todos eles precisam de acesso à Internet,

707
00:49:05,090 --> 00:49:08,100
mas o computador só tem uma placa Wi-Fi ou o que seja.

708
00:49:08,100 --> 00:49:10,780
Assim, os portos são a maneira que nós somos capazes de dividir

709
00:49:10,780 --> 00:49:13,550
como esses aplicativos são capazes de usar a Internet.

710
00:49:13,550 --> 00:49:17,230
Cada aplicativo obtém uma porta específica que possa escutar,

711
00:49:17,230 --> 00:49:19,670
e, por padrão, HTTP usa a porta 80.

712
00:49:19,670 --> 00:49:22,410
Alguns serviços de e-mail usar 25.

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

714
00:49:24,490 --> 00:49:29,270
Você geralmente são capazes de obter os com numeração mais alta para si mesmo.

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

716
00:49:32,010 --> 00:49:36,030
Páginas web Nós estilo com CSS, não com HTML.

717
00:49:36,030 --> 00:49:38,440
Existem 3 lugares que você pode colocar o seu CSS.

718
00:49:38,440 --> 00:49:46,300
Ele pode ser in-line, entre marcas de estilo, ou em um arquivo separado e, em seguida, completamente ligado dentro

719
00:49:46,300 --> 00:49:48,470
E aqui é apenas um exemplo de CSS.

720
00:49:48,470 --> 00:49:50,450
Você deve reconhecer esse padrão,

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

722
00:49:54,310 --> 00:49:56,680
e aqui estamos centrando a tag body.

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

724
00:50:00,420 --> 00:50:04,740
com ID de rodapé, e estamos aplicando alguns estilos para isso.

725
00:50:04,740 --> 00:50:07,310
Observe que o ID de rodapé de texto alinha à esquerda,

726
00:50:07,310 --> 00:50:09,840
enquanto alinha texto corpo central.

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

728
00:50:13,180 --> 00:50:16,470
Será, em vez disso, text-align esquerda, mesmo que o corpo diz centro text-align.

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

730
00:50:18,880 --> 00:50:22,110
Você pode ter - você pode especificar estilos para o corpo,

731
00:50:22,110 --> 00:50:25,320
e depois as coisas no corpo que você pode especificar estilos mais específicos,

732
00:50:25,320 --> 00:50:28,160
e as coisas funcionam como o esperado.

733
00:50:28,160 --> 00:50:34,420
Especificadores CSS mais específicas têm precedência.

734
00:50:34,420 --> 00:50:46,140
Eu acho que é isso.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Olá a todos. Se eu pudesse chamar sua atenção.

736
00:50:49,260 --> 00:50:53,990
Estou Ali e eu vou passar por PHP e SQL muito rápido.

737
00:50:53,990 --> 00:51:00,310
Assim, podemos começar. PHP é curto para PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
E como todos vocês devem saber, é uma linguagem de script do lado do servidor,

739
00:51:03,730 --> 00:51:06,800
e usá-lo para o back-end de sites,

740
00:51:06,800 --> 00:51:12,540
e como ele faz um monte de cálculos, a parte por trás cenas.

741
00:51:12,540 --> 00:51:17,510
Syntax. Não é como C, surpresa, surpresa.

742
00:51:17,510 --> 00:51:22,060
Ele sempre tem que começar com a, se você pode ver, o - eu não posso seguir em frente.

743
00:51:22,060 --> 00:51:31,340
Você pode ver o que você precisa os novos tipos de aparelhos e, em seguida, você também precisa do? Php.

744
00:51:31,340 --> 00:51:35,780
Isso é sempre como você tem que enquadrar o texto PHP, seu código PHP.

745
00:51:35,780 --> 00:51:39,180
Portanto, não pode ser igual a C, onde o tipo de colocá-lo em primeiro lugar.

746
00:51:39,180 --> 00:51:42,290
Você precisa cercar-lo sempre.

747
00:51:42,290 --> 00:51:47,610
E agora, a maior sintaxe é que todas as variáveis ​​precisa para começar com o caractere $.

748
00:51:47,610 --> 00:51:49,490
Você precisa fazê-lo quando você está definindo-os, você precisa fazê-lo

749
00:51:49,490 --> 00:51:51,860
quando você está se referindo a eles mais tarde.

750
00:51:51,860 --> 00:51:56,510
Você sempre precisa que US $. É o seu novo melhor amigo, muito bonito.

751
00:51:56,510 --> 00:52:01,690
Você não - ao contrário de C, você não precisa colocar que tipo de tipo de variável que é.

752
00:52:01,690 --> 00:52:04,940
Então, enquanto você precisa fazer o $, você não precisa colocar, como,

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

754
00:52:09,470 --> 00:52:11,490
Então, uma pequena diferença.

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

756
00:52:15,590 --> 00:52:19,310
PHP é uma linguagem de tipo fracamente, e tem variáveis ​​fracamente digitado.

757
00:52:19,310 --> 00:52:24,020
Em outras palavras, isso significa que você pode alternar entre os diferentes tipos de tipos de variáveis.

758
00:52:24,020 --> 00:52:27,230
Você pode armazenar seu número 1 como um int,

759
00:52:27,230 --> 00:52:29,650
você pode armazená-lo como uma string, e você pode armazená-lo como um float,

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

761
00:52:33,550 --> 00:52:36,080
Mesmo que você esteja armazenando-o em diferentes formas,

762
00:52:36,080 --> 00:52:39,120
ainda é - os tipos de variáveis ​​ainda estão segurando no final.

763
00:52:39,120 --> 00:52:41,540
Então, se você olhar aqui, se você se lembrar de pset 7,

764
00:52:41,540 --> 00:52:43,500
muitos de vocês provavelmente teve problemas com isso.

765
00:52:43,500 --> 00:52:47,280
Dois sinais iguais, três sinais de igual, 4 sinais de igual.

766
00:52:47,280 --> 00:52:49,990
Ok, não há quatro sinais de igual, mas existem 2 e 3.

767
00:52:49,990 --> 00:52:53,320
Você pode usar dois sinais de igual para verificar os valores.

768
00:52:53,320 --> 00:52:55,830
É possível verificar em todos os tipos.

769
00:52:55,830 --> 00:52:58,770
Então, se você pode ver no primeiro exemplo,

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

771
00:53:02,210 --> 00:53:06,710
Portanto, o seu int e sua seqüência são ambos, tecnicamente, 1,

772
00:53:06,710 --> 00:53:10,790
mas são tipos diferentes. Mas para os dois iguais, ainda vou passar.

773
00:53:10,790 --> 00:53:15,510
No entanto, para os três iguais, verifica valor, bem como os diferentes tipos.

774
00:53:15,510 --> 00:53:18,760
Isso significa que ele não vai passar nesse segundo caso aqui,

775
00:53:18,760 --> 00:53:22,350
onde você estiver usando três sinais de igual em seu lugar.

776
00:53:22,350 --> 00:53:26,590
Então, isso é uma grande diferença que você deve tudo têm mostrado agora.

777
00:53:26,590 --> 00:53:31,570
>> Concatenação de String é outra coisa poderosa que você pode usar em PHP.

778
00:53:31,570 --> 00:53:34,080
É basicamente esta a notação de ponto à mão,

779
00:53:34,080 --> 00:53:36,230
e é assim que você pode ligar cordas juntos.

780
00:53:36,230 --> 00:53:40,800
Então se você tem gato e você tem cão, e você quer colocar as duas cordas juntas,

781
00:53:40,800 --> 00:53:44,080
você pode usar o período, e isso é tipo de como ele funciona.

782
00:53:44,080 --> 00:53:46,660
Você também pode simplesmente colocá-los ao lado do outro,

783
00:53:46,660 --> 00:53:49,030
como você pode ver aqui no exemplo de fundo,

784
00:53:49,030 --> 00:53:51,610
onde eu eco seqüência 1, corda espaço 2.

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

786
00:53:56,930 --> 00:53:59,780
Arrays. Agora, em PHP, existem dois tipos diferentes de matrizes.

787
00:53:59,780 --> 00:54:03,180
Você pode ter matrizes regulares, e você também pode ter arrays associativos,

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

789
00:54:06,040 --> 00:54:08,280
Matrizes regulares são apenas isso em C,

790
00:54:08,280 --> 00:54:11,240
e por isso você tem índices que são numerados.

791
00:54:11,240 --> 00:54:13,160
Agora estamos indo só para criar um e colocá -

792
00:54:13,160 --> 00:54:15,500
então é assim que criar uma matriz vazia, então vamos

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

794
00:54:17,310 --> 00:54:19,200
Nós vamos colocar o número 6, o valor 6.

795
00:54:19,200 --> 00:54:21,500
Você pode vê-lo na parte inferior aqui.

796
00:54:21,500 --> 00:54:24,240
Where's - pelo número de índice 1, vamos colocar o número valor 4,

797
00:54:24,240 --> 00:54:26,720
e assim você pode ver que há um 6, há um 4,

798
00:54:26,720 --> 00:54:29,160
e então, como estamos imprimindo coisas,

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

800
00:54:33,550 --> 00:54:36,900
então vamos ver o valor 6 sendo impresso. Legal?

801
00:54:36,900 --> 00:54:40,160
Então, isso é matrizes regulares para você.

802
00:54:40,160 --> 00:54:42,750
Outra forma que você também pode adicionar coisas para matrizes regulares agora

803
00:54:42,750 --> 00:54:44,780
é que você pode simplesmente anexá-los no final.

804
00:54:44,780 --> 00:54:47,240
Isso significa que você não tem que especificar o índice específico.

805
00:54:47,240 --> 00:54:51,000
Você pode ver o número e, em seguida, entre colchetes não há nenhum índice especificado.

806
00:54:51,000 --> 00:54:56,270
E vai saber - PHP saberá apenas adicioná-lo ao final da lista, o próximo lugar livre.

807
00:54:56,270 --> 00:54:59,190
Assim você pode ver o 1 ali, naquele 0 spot,

808
00:54:59,190 --> 00:55:02,690
o 2 foi para a direita lá no primeiro lugar.

809
00:55:02,690 --> 00:55:04,690
O 3 vai - é adicionado lá também.

810
00:55:04,690 --> 00:55:06,720
Então, esse tipo de faz sentido. Você só está constantemente adicionando-lo,

811
00:55:06,720 --> 00:55:09,360
e então, quando estamos exibindo o índice de número 1,

812
00:55:09,360 --> 00:55:13,080
ele irá imprimir o valor 2.

813
00:55:13,080 --> 00:55:16,800
>> Então temos matrizes que são arrays associativos.

814
00:55:16,800 --> 00:55:19,370
As matrizes de associação, em vez de ter índices numéricos,

815
00:55:19,370 --> 00:55:23,630
o que eles fazem é, eles têm índices que estão por string.

816
00:55:23,630 --> 00:55:25,670
Você pode ver, em vez de - Eu me livrei de todos os índices numéricos,

817
00:55:25,670 --> 00:55:32,140
e agora é key1, key2, key3, e eles estão entre aspas para significar que eles estão todos os strings.

818
00:55:32,140 --> 00:55:34,470
Assim, podemos ter um exemplo disso.

819
00:55:34,470 --> 00:55:38,790
O exemplo disso é que temos o tf, e isso é o nome do índice.

820
00:55:38,790 --> 00:55:42,030
Vamos colocar "Ali", como o nome, no índice, calorias ingeridas,

821
00:55:42,030 --> 00:55:47,640
podemos colocar um int desta vez em vez de uma string,

822
00:55:47,640 --> 00:55:52,240
e depois para os gostos de índice, podemos colocar uma matriz inteira dentro dela.

823
00:55:52,240 --> 00:55:55,490
Portanto, esta é uma espécie de - é um conceito semelhante à forma como tivemos

824
00:55:55,490 --> 00:55:58,930
índices com números, mas agora nós podemos mudar os índices em torno de

825
00:55:58,930 --> 00:56:03,890
para tê-los como strings em vez.

826
00:56:03,890 --> 00:56:06,070
Você também pode fazer isso, além de apenas fazê-lo individualmente,

827
00:56:06,070 --> 00:56:09,400
você pode fazer tudo em um só pedaço. Assim você pode ver que tf desse array,

828
00:56:09,400 --> 00:56:13,350
e, então, colocá-los todos em um conjunto gigante colchete.

829
00:56:13,350 --> 00:56:15,220
Assim que pode acelerar as coisas.

830
00:56:15,220 --> 00:56:19,730
É mais do que uma escolha estilística que não.

831
00:56:19,730 --> 00:56:21,550
Temos também loops.

832
00:56:21,550 --> 00:56:26,020
Em C temos laços que trabalham assim.

833
00:56:26,020 --> 00:56:29,690
Tivemos a nossa matriz, e fomos de índice 0 para o final da lista,

834
00:56:29,690 --> 00:56:31,740
e nós imprimi-lo de tudo, certo?

835
00:56:31,740 --> 00:56:33,880
Exceto o problema é que, para arrays associativos,

836
00:56:33,880 --> 00:56:36,610
não necessariamente sabe aqueles índices numéricos

837
00:56:36,610 --> 00:56:39,610
porque agora temos os índices de cordas.

838
00:56:39,610 --> 00:56:44,800
Agora usamos loops foreach, que, mais uma vez, você esperançosamente usados ​​em pset 7.

839
00:56:44,800 --> 00:56:48,930
Loops foreach só vai saber cada parte da lista.

840
00:56:48,930 --> 00:56:52,450
E ele não tem que saber exatamente o índice numérico que você tem.

841
00:56:52,450 --> 00:56:56,490
Então você tem a sintaxe foreach, por isso é foreach, você coloca a matriz.

842
00:56:56,490 --> 00:57:00,430
Assim, a minha matriz é chamado pset, e depois como, a palavra como,

843
00:57:00,430 --> 00:57:04,530
e então você coloca esta variável temporária local que você vai usar

844
00:57:04,530 --> 00:57:10,690
apenas para a coisa específica que vai segurar o específico -

845
00:57:10,690 --> 00:57:14,770
uma instância ou uma seção da matriz.

846
00:57:14,770 --> 00:57:18,350
Pset num vai realizar 1, e então talvez ele vai segurar o número 6,

847
00:57:18,350 --> 00:57:20,410
e, em seguida, que irá realizar o número 2.

848
00:57:20,410 --> 00:57:26,630
Mas está garantido para passar por cada valor único que está na matriz.

849
00:57:26,630 --> 00:57:30,530
Funções úteis que você deve saber em PHP são o exigirem,

850
00:57:30,530 --> 00:57:35,880
de modo que torna-se de que você está incluindo determinados arquivos, eco, saída, vazio.

851
00:57:35,880 --> 00:57:40,490
Eu recomendo que você olhar para pset 7 e olhar para essas funções.

852
00:57:40,490 --> 00:57:42,810
Você pode ter que saber quem,

853
00:57:42,810 --> 00:57:47,060
então eu definitivamente sei o que, exatamente, aqueles que estão fazendo.

854
00:57:47,060 --> 00:57:50,080
>> E agora vamos passar por escopo muito rapidamente.

855
00:57:50,080 --> 00:57:53,490
Em âmbito, o PHP é um tipo de coisa funky, ao contrário de C,

856
00:57:53,490 --> 00:57:56,170
e por isso estamos indo só para passar por isso rapidamente.

857
00:57:56,170 --> 00:57:58,930
Então, digamos que começamos naquela seta que temos lá.

858
00:57:58,930 --> 00:58:02,900
E vamos começar com $ i. Assim, a variável 'i' vai ser 0,

859
00:58:02,900 --> 00:58:06,730
e nós apenas estamos indo para mantê-imprimi-lo na medida em que grande caixa branca por lá.

860
00:58:06,730 --> 00:58:09,220
Nós vamos começar com i0, e então nós estamos indo para representá-la.

861
00:58:09,220 --> 00:58:12,670
Portanto, há a 0.

862
00:58:12,670 --> 00:58:15,210
E então nós estamos indo para incrementa-o com o laço para,

863
00:58:15,210 --> 00:58:17,810
e, em seguida, ele vai ser o valor de 1.

864
00:58:17,810 --> 00:58:20,070
Um deles é menor do que 3, então ele vai passar por isso para loop,

865
00:58:20,070 --> 00:58:23,230
e, em seguida, vamos vê-lo impresso novamente.

866
00:58:23,230 --> 00:58:25,520
Nós estamos indo para incrementá-lo novamente a 2,

867
00:58:25,520 --> 00:58:29,860
e 2 é inferior a 3, por isso vou passar o loop for, e ele vai imprimir a 2.

868
00:58:29,860 --> 00:58:35,100
Em seguida, você vai notar que 3 não é inferior a 3, por isso vamos sair do loop for.

869
00:58:35,100 --> 00:58:40,050
Então, agora nós saiu, e então nós estamos indo para ir em AFunction.

870
00:58:40,050 --> 00:58:45,010
Okay. Então você tem que notar que esta variável que criamos,

871
00:58:45,010 --> 00:58:48,270
a variável 'i', não tem como escopo localmente.

872
00:58:48,270 --> 00:58:50,280
Isso significa que não é local para o loop,

873
00:58:50,280 --> 00:58:58,060
e essa variável ainda pode acessar e alterar depois, e ainda vai ser eficaz.

874
00:58:58,060 --> 00:59:02,160
Então, se você vai para a função de agora, você vai ver que nós também usamos o 'i' variável,

875
00:59:02,160 --> 00:59:05,320
e vamos incrementar 'i' + +.

876
00:59:05,320 --> 00:59:09,410
Você pensaria que, num primeiro momento, com base em C, que é uma cópia do 'i' variável.

877
00:59:09,410 --> 00:59:12,830
É uma coisa totalmente diferente, o que é correto.

878
00:59:12,830 --> 00:59:16,560
Então, quando nós imprimi-lo, vamos imprimir 'i' + +, que vai imprimir que 4,

879
00:59:16,560 --> 00:59:19,640
e, em seguida, vamos - desculpe.

880
00:59:19,640 --> 00:59:22,030
Então vamos acabar fora dessa função,

881
00:59:22,030 --> 00:59:24,820
e nós estamos indo para estar onde a seta é agora.

882
00:59:24,820 --> 00:59:29,190
Isso significa que, em seguida, no entanto, mesmo que a função alterado o valor de 'i',

883
00:59:29,190 --> 00:59:32,620
não se alterou fora da função,

884
00:59:32,620 --> 00:59:35,060
porque a função tem um escopo separado.

885
00:59:35,060 --> 00:59:38,960
Isso significa que quando nós echo 'i', não mudou no âmbito da função,

886
00:59:38,960 --> 00:59:43,660
e assim, em seguida, vamos para imprimir 3 novamente.

887
00:59:43,660 --> 00:59:47,520
Diferentes coisas sobre escopo em PHP do que em C.

888
00:59:47,520 --> 00:59:51,130
>> Agora em PHP e HTML.

889
00:59:51,130 --> 00:59:53,510
PHP é usada para tornar as páginas web dinâmicas.

890
00:59:53,510 --> 00:59:58,660
É algo que faz coisas diferentes.

891
00:59:58,660 --> 01:00:02,090
Nós temos que é diferente de HTML.

892
01:00:02,090 --> 01:00:05,230
Com HTML, que sempre só tem a mesma coisa estática, como a forma como Rob mostrou,

893
01:00:05,230 --> 01:00:09,370
enquanto o PHP, você pode mudar as coisas com base em quem é o usuário.

894
01:00:09,370 --> 01:00:11,830
Então, se eu tiver isso, eu, "Você está logado como -" e, em seguida, o nome,

895
01:00:11,830 --> 01:00:14,420
e eu posso mudar o nome. Então, agora o nome é José,

896
01:00:14,420 --> 01:00:18,880
e tem o "sobre mim", mas então eu também posso mudar o nome para ter Tommy.

897
01:00:18,880 --> 01:00:21,700
E isso seria uma coisa diferente.

898
01:00:21,700 --> 01:00:23,840
Então nós também podemos mudar as coisas diferentes sobre ele,

899
01:00:23,840 --> 01:00:27,070
e ele vai mostrar conteúdo diferente com base no nome.

900
01:00:27,070 --> 01:00:31,430
Então PHP pode tipo de mudar o que está acontecendo em seu site.

901
01:00:31,430 --> 01:00:33,540
O mesmo aqui. Ainda assim, note que eles têm conteúdo diferente,

902
01:00:33,540 --> 01:00:38,870
mesmo que você está tecnicamente ainda acessar essa mesma página da web na superfície.

903
01:00:38,870 --> 01:00:43,450
Gerando HTML. Existem 2 maneiras diferentes que você pode fazer isso.

904
01:00:43,450 --> 01:00:48,980
Então, nós vamos passar por isso agora. A primeira forma é, você tem - sim, muito.

905
01:00:48,980 --> 01:00:51,150
Então você acabou de ter o seu regular para laço em PHP,

906
01:00:51,150 --> 01:00:56,270
e então você ecoar em PHP e HTML echo fora.

907
01:00:56,270 --> 01:00:58,720
Usando o que Rob lhe mostrou de script HTML

908
01:00:58,720 --> 01:01:04,030
e em seguida, usando a impressão PHP apenas imprimi-lo para a página de web.

909
01:01:04,030 --> 01:01:09,520
O caminho alternativo é fazê-lo como se você separar o PHP e HTML.

910
01:01:09,520 --> 01:01:11,940
Assim, você pode ter uma linha de PHP que inicia o loop for,

911
01:01:11,940 --> 01:01:16,020
então você pode ter a linha do HTML em uma coisa separada,

912
01:01:16,020 --> 01:01:19,700
e então você terminar o loop, mais uma vez, com um PHP.

913
01:01:19,700 --> 01:01:21,800
Então, é uma espécie de separá-lo para fora.

914
01:01:21,800 --> 01:01:24,020
No lado esquerdo, você pode que você tem todo o -

915
01:01:24,020 --> 01:01:26,360
é apenas um pedaço de PHP.

916
01:01:26,360 --> 01:01:28,510
À direita, você pode ver que você tem uma linha de PHP,

917
01:01:28,510 --> 01:01:32,540
você tem uma linha de HTML, e você tem uma linha de PHP novamente.

918
01:01:32,540 --> 01:01:36,870
Assim, separando-o para fora o que estão fazendo.

919
01:01:36,870 --> 01:01:39,330
E você vai notar que de qualquer forma, para qualquer um deles,

920
01:01:39,330 --> 01:01:41,980
eles ainda imprimir a imagem, a imagem, a imagem,

921
01:01:41,980 --> 01:01:44,540
de modo que o HTML ainda é impresso da mesma forma.

922
01:01:44,540 --> 01:01:49,870
E então, você ainda vai ver as 3 imagens aparecem em seu site.

923
01:01:49,870 --> 01:01:52,820
Portanto, é de 2 maneiras diferentes de fazer a mesma coisa.

924
01:01:52,820 --> 01:01:55,060
>> Agora temos formas e solicitações. Como Rob mostrou você,

925
01:01:55,060 --> 01:01:59,400
existem formas de HTML, e vamos apenas brisa através deste.

926
01:01:59,400 --> 01:02:02,040
Você tem uma ação e você tem um método, e sua ação

927
01:02:02,040 --> 01:02:04,350
tipo de mostra onde você está indo para enviá-lo, eo método é se

928
01:02:04,350 --> 01:02:06,960
ele vai ser um GET ou um POST.

929
01:02:06,960 --> 01:02:11,220
E um pedido GET, como disse Rob, significa que você está indo para colocá-lo em uma forma

930
01:02:11,220 --> 01:02:15,760
e você vai vê-lo como uma URL, enquanto uma solicitação POST você não vai ver em uma URL.

931
01:02:15,760 --> 01:02:17,840
Então, uma pequena diferença.

932
01:02:17,840 --> 01:02:19,950
No entanto, uma coisa que é uma coisa semelhante

933
01:02:19,950 --> 01:02:22,560
é que POST e GET são igualmente inseguro.

934
01:02:22,560 --> 01:02:26,430
Assim, você pode pensar que, só porque você não vê-lo na URL,

935
01:02:26,430 --> 01:02:28,790
isso significa que o POST é mais seguro,

936
01:02:28,790 --> 01:02:34,420
mas você ainda pode vê-lo em seus cookies nas informações que você está enviando.

937
01:02:34,420 --> 01:02:38,260
Então, não acho que cerca de um ou de outro.

938
01:02:38,260 --> 01:02:42,160
Outra coisa a notar é que você também tem variáveis ​​de seção.

939
01:02:42,160 --> 01:02:45,850
Vocês usaram esta em pset 7 para obter a sua informação ID de usuário.

940
01:02:45,850 --> 01:02:48,550
O que aconteceu foi que você pode usar essa matriz associativa,

941
01:02:48,550 --> 01:02:53,310
o $ _SESSION, e então você é capaz de acessar coisas diferentes

942
01:02:53,310 --> 01:02:57,720
e armazenar coisas diferentes através das páginas.

943
01:02:57,720 --> 01:03:00,750
>> A última coisa é que temos SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
e esta é uma linguagem de programação para gerenciar bancos de dados.

945
01:03:04,360 --> 01:03:08,220
O que, exatamente, são bancos de dados? Eles são coleções de tabelas,

946
01:03:08,220 --> 01:03:10,630
e cada tabela pode ter tipos semelhantes de objetos.

947
01:03:10,630 --> 01:03:14,990
Então, tivemos uma mesa de usuários em seu pset finanças.

948
01:03:14,990 --> 01:03:20,610
E por que eles são úteis? Porque é uma forma de armazenar permanentemente a informação.

949
01:03:20,610 --> 01:03:22,840
É uma maneira de rastrear coisas e administrar as coisas

950
01:03:22,840 --> 01:03:25,890
e realmente vê-lo em diferentes páginas e manter o controle.

951
01:03:25,890 --> 01:03:29,930
Enquanto que se você apenas armazená-lo em um momento que imediato

952
01:03:29,930 --> 01:03:33,720
e usá-lo mais tarde, você não será capaz de acessar qualquer coisa que você salvou.

953
01:03:33,720 --> 01:03:37,660
Temos 4 coisas importantes que utilizamos para comandos SQL.

954
01:03:37,660 --> 01:03:40,190
Temos select, insert, delete e update.

955
01:03:40,190 --> 01:03:42,880
Essas são realmente importante para vocês para saber para o seu quiz.

956
01:03:42,880 --> 01:03:45,990
>> Vamos rapidamente sobre selecione agora.

957
01:03:45,990 --> 01:03:48,540
Basicamente, você está selecionando linhas de um banco de dados.

958
01:03:48,540 --> 01:03:52,400
Então, se você tem, bem aqui -

959
01:03:52,400 --> 01:03:56,740
temos estas duas coisas diferentes, e queremos selecionar da tabela de aulas

960
01:03:56,740 --> 01:04:01,480
onde incrível - onde na coluna incrível o valor é 1.

961
01:04:01,480 --> 01:04:04,460
Assim você pode ver aqui, temos essas duas coisas do nome da classe,

962
01:04:04,460 --> 01:04:08,490
CS50 e Stat110, e temos os IDs de classe e do slogan.

963
01:04:08,490 --> 01:04:13,150
Por isso, queremos selecionar todas essas informações.

964
01:04:13,150 --> 01:04:17,480
Então você pode ver aqui que é uma espécie de escolher dessa coluna incrível,

965
01:04:17,480 --> 01:04:25,170
onde todas as coisas são um, e então ele tem a classe ID, nome da classe e slogan que ele pode escolher.

966
01:04:25,170 --> 01:04:28,100
Como exatamente você fazer isso no código? Você tem que usar PHP.

967
01:04:28,100 --> 01:04:33,830
Então, esse é o tipo de como PHP e SQL são relacionados uns aos outros.

968
01:04:33,830 --> 01:04:38,130
Agora temos o nosso código, e vamos usar a nossa função de consulta

969
01:04:38,130 --> 01:04:41,370
como fizemos no pset 7, e nós estamos indo para executar a consulta SQL.

970
01:04:41,370 --> 01:04:43,870
Então nós vamos ter -

971
01:04:43,870 --> 01:04:46,280
a gente sempre tem que verificar se o triplo igual de linha se falsa.

972
01:04:46,280 --> 01:04:49,010
Então, novamente, você quer verificar o tipo eo valor,

973
01:04:49,010 --> 01:04:53,880
e, em seguida, se não funcionar, então você quer se desculpar, como de costume, como fizemos no pset 7.

974
01:04:53,880 --> 01:04:55,870
Caso contrário, você quiser percorrer tudo com aqueles acessíveis

975
01:04:55,870 --> 01:04:59,410
foreach loop que nós apenas passou.

976
01:04:59,410 --> 01:05:01,280
Agora que estamos loop e temos conseguido vencer,

977
01:05:01,280 --> 01:05:05,080
vamos supor que a nossa consulta passou, agora temos o nosso loop foreach.

978
01:05:05,080 --> 01:05:11,050
E a primeira linha tem, então aqui está a linha, aqui, é encaixotado.

979
01:05:11,050 --> 01:05:14,010
Vai imprimir toda a informação que é chegado.

980
01:05:14,010 --> 01:05:18,070
Então, ele vai imprimir na parte inferior "Wanna Saiba HTML?"

981
01:05:18,070 --> 01:05:23,370
Então está indo para ir para a próxima linha, porque está concluído o primeiro ciclo for,

982
01:05:23,370 --> 01:05:26,510
e assim, em seguida, ele vai imprimir a segunda linha do mesmo,

983
01:05:26,510 --> 01:05:32,120
que vai ser STAT110, Localizar todos os momentos.

984
01:05:32,120 --> 01:05:34,290
>> Uma última coisa é sobre as vulnerabilidades de SQL.

985
01:05:34,290 --> 01:05:37,300
Eu sei que David tocou neste um pouco na aula.

986
01:05:37,300 --> 01:05:40,730
Você pode ler mais tarde. É muito engraçado.

987
01:05:40,730 --> 01:05:45,320
SQL Injection é um tipo de coisa complicada.

988
01:05:45,320 --> 01:05:49,890
Digamos que você se ater apenas essas variáveis ​​para a direita em sua consulta,

989
01:05:49,890 --> 01:05:52,290
como você pode ver nessa primeira linha.

990
01:05:52,290 --> 01:05:54,520
Assim, parece bem, certo? Você está apenas colocando o nome de utilizador

991
01:05:54,520 --> 01:05:58,820
e senha para sua consulta SQL, e você quer enviá-lo fora e conseguir tudo o que está na sua tabela de dados.

992
01:05:58,820 --> 01:06:01,450
Isso parece bastante simples. Então, digamos que alguém coloca em,

993
01:06:01,450 --> 01:06:04,910
para a senha, este ou texto aqui -

994
01:06:04,910 --> 01:06:06,780
realmente deve ser na caixa vermelha.

995
01:06:06,780 --> 01:06:11,920
Então, vamos dizer que eles colocaram essa senha em - que é o que eles entram.

996
01:06:11,920 --> 01:06:16,520
Então, eles estão colocando ou "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Uma espécie de senha boba de ter.

998
01:06:20,880 --> 01:06:25,070
Agora vamos substituí-lo, e você vai notar que nessa consulta SQL agora,

999
01:06:25,070 --> 01:06:29,090
avalia para sempre verdadeiro, porque você vai notar que

1000
01:06:29,090 --> 01:06:32,240
você pode consulta SQL selecionar todas essas informações

1001
01:06:32,240 --> 01:06:35,420
ou você pode apenas ter 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
De modo que sempre vai avaliar para true.

1003
01:06:41,030 --> 01:06:46,610
Isso não vai realmente funcionar, porque isso significa que o hacker pode invadir seu sistema.

1004
01:06:46,610 --> 01:06:49,300
A solução para isso é que você tem que usar o sistema de DOP,

1005
01:06:49,300 --> 01:06:51,360
o que significa que você tem que usar pontos de interrogação,

1006
01:06:51,360 --> 01:06:53,350
que é o que vocês usados ​​na pset 7,

1007
01:06:53,350 --> 01:06:57,620
onde você está indo para usar um ponto de interrogação no lugar de onde você quer colocar alguma coisa,

1008
01:06:57,620 --> 01:07:01,430
e então você vai ter uma vírgula, e então você vai ter depois,

1009
01:07:01,430 --> 01:07:07,610
depois de sua seqüência, as diferentes variáveis ​​que você deseja substituir no seu ponto de interrogação.

1010
01:07:07,610 --> 01:07:10,330
Então, você vai notar que agora eu tenho esses pontos de interrogação vermelhos.

1011
01:07:10,330 --> 01:07:15,420
Então eu coloquei as variáveis ​​após minhas cordas, então eu sei que substituí-los nessa ordem depois.

1012
01:07:15,420 --> 01:07:18,470
Isso irá certificar-se de que, se alguém faz isso assim,

1013
01:07:18,470 --> 01:07:24,050
e eles têm o ou 1 = 1 situação, que irá certificar-se,

1014
01:07:24,050 --> 01:07:30,490
no final de volta, certifique-se que ele não vai realmente quebrar a consulta SQL.

1015
01:07:30,490 --> 01:07:33,660
Ok, então isso é muito bonito isso, um turbilhão de PHP e SQL.

1016
01:07:33,660 --> 01:07:41,520
Boa sorte para todos vocês, e agora para Oregon

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] todos Okay. Tempo para percorrer algumas JavaScript

1018
01:07:44,270 --> 01:07:48,840
e algumas outras coisas muito rapidamente, então nós não prendê-lo esta noite.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Sim. JavaScript é uma espécie de coisa legal, supostamente.

1020
01:07:56,930 --> 01:07:59,090
As coisas que você realmente precisa saber sobre JavaScript, é mais ou menos como

1021
01:07:59,090 --> 01:08:03,810
o fim do lado do cliente do que o seu aplicativo web vai estar fazendo.

1022
01:08:03,810 --> 01:08:08,280
Há algumas coisas que você simplesmente não querem cuidar de todo o tempo no lado do servidor.

1023
01:08:08,280 --> 01:08:12,880
Todas as pequenas interações, com destaque para uma coisa, fazer algo desaparecer.

1024
01:08:12,880 --> 01:08:15,340
Você realmente não quero ter que falar com o seu servidor de todo o tempo para isso.

1025
01:08:15,340 --> 01:08:18,069
E alguns que nem sequer é possível fazer no lado do servidor.

1026
01:08:18,069 --> 01:08:21,899
É por isso que precisamos de algo como JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Coisas legais sobre JavaScript: Ele é digitado de forma dinâmica.

1028
01:08:24,359 --> 01:08:27,149
O que isto significa é que o seu programa não precisa saber

1029
01:08:27,149 --> 01:08:30,970
o que, exatamente, as variáveis ​​são quando você escrevê-lo.

1030
01:08:30,970 --> 01:08:34,510
Vai apenas uma espécie de descobrir como ele está correndo.

1031
01:08:34,510 --> 01:08:37,520
Outras coisas que são legais sobre isso: É uma linguagem de chaveta,

1032
01:08:37,520 --> 01:08:41,359
o que significa que a sintaxe é semelhante a C e PHP.

1033
01:08:41,359 --> 01:08:47,050
Você não tem que fazer muito retrabalho quando você está aprendendo JavaScript.

1034
01:08:47,050 --> 01:08:49,180
Aqui temos um pouco de JavaScript.

1035
01:08:49,180 --> 01:08:52,560
Uma coisa interessante aqui é que, se você olhar para ele,

1036
01:08:52,560 --> 01:08:56,330
nós temos um pouco de JavaScript ali na marca de cabeça.

1037
01:08:56,330 --> 01:08:59,479
O que é que é, basicamente, basta incluir um arquivo JavaScript.

1038
01:08:59,479 --> 01:09:02,260
Esta é uma maneira que você pode incluir JavaScript em seu programa.

1039
01:09:02,260 --> 01:09:06,910
Em seguida, o segundo pouco é realmente alguma JavaScript inline,

1040
01:09:06,910 --> 01:09:10,790
muito semelhante a um estilo em linha com CSS,

1041
01:09:10,790 --> 01:09:16,180
e você está apenas escrevendo alguns códigos muito rapidamente lá.

1042
01:09:16,180 --> 01:09:18,120
JavaScript tem arrays.

1043
01:09:18,120 --> 01:09:20,850
Apenas uma outra maneira de manter os dados ao redor, muito útil.

1044
01:09:20,850 --> 01:09:25,180
Muito agradável e fácil de sintaxe.

1045
01:09:25,180 --> 01:09:29,870
Você pode usar colchetes para acessar tudo e manter tudo junto.

1046
01:09:29,870 --> 01:09:35,020
Nada muito complexo.

1047
01:09:35,020 --> 01:09:38,630
A coisa legal sobre JavaScript e linguagens de script em geral

1048
01:09:38,630 --> 01:09:40,920
é que você não precisa se preocupar com tamanhos de matriz.

1049
01:09:40,920 --> 01:09:43,880
Você pode apenas usar array.length e manter o controle do mesmo,

1050
01:09:43,880 --> 01:09:46,960
e também a matriz pode crescer ou encolher como você precisa dele.

1051
01:09:46,960 --> 01:09:49,279
Assim, você não precisa nem se preocupar com qualquer tipo de,

1052
01:09:49,279 --> 01:09:57,050
oh não, eu preciso alocar mais coisas, ou qualquer coisa assim.

1053
01:09:57,050 --> 01:10:00,090
>> O legal aqui é que o JavaScript tem algo chamado objetos.

1054
01:10:00,090 --> 01:10:04,800
É uma linguagem orientada a objeto, então o que ele tem é, essencialmente,

1055
01:10:04,800 --> 01:10:10,100
uma maneira de você para agrupar dados em conjunto, algo semelhante a uma estrutura,

1056
01:10:10,100 --> 01:10:17,280
mas você pode acessá-la como uma estrutura ou em uma sintaxe de array associativo.

1057
01:10:17,280 --> 01:10:22,520
É muito simples e que você pode fazer com isso é agrupar dados juntos

1058
01:10:22,520 --> 01:10:24,810
se você tem um monte de dados que está relacionado.

1059
01:10:24,810 --> 01:10:26,850
Porque é tudo o que você precisa para descrever um carro,

1060
01:10:26,850 --> 01:10:29,050
você não precisa tê-lo em um monte de lugares diferentes.

1061
01:10:29,050 --> 01:10:35,300
Você pode simplesmente colocá-lo em um objeto em JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Como você provavelmente sabe, a iteração é uma daquelas tarefas tediosas.

1063
01:10:39,090 --> 01:10:43,810
Você só faz isso através de uma outra vez. Você precisa falar com todos os objetos no carro,

1064
01:10:43,810 --> 01:10:47,340
ou você precisa passar por cada item em uma lista ou algo parecido.

1065
01:10:47,340 --> 01:10:51,770
Então tem JavaScript, semelhante ao PHP, uma sintaxe foreach.

1066
01:10:51,770 --> 01:10:54,590
Neste caso, é um no loop.

1067
01:10:54,590 --> 01:10:57,300
Você quer usar isto só em objetos.

1068
01:10:57,300 --> 01:11:01,030
Existem alguns problemas que ocorrem se você usar isso em matrizes.

1069
01:11:01,030 --> 01:11:03,750
De modo geral, é uma daquelas coisas que, no entanto, que é muito útil,

1070
01:11:03,750 --> 01:11:06,590
porque você elimina um monte de sobrecarga

1071
01:11:06,590 --> 01:11:10,270
porque você não tem que puxar tudo ao seu objeto por si mesmo.

1072
01:11:10,270 --> 01:11:12,300
Você não tem que se lembrar de todos os nomes-chave.

1073
01:11:12,300 --> 01:11:18,270
Você só tipo de levá-los de volta nesta sintaxe.

1074
01:11:18,270 --> 01:11:21,500
Neste, por, você só quer lembrar

1075
01:11:21,500 --> 01:11:27,180
que você está recebendo de volta todas as chaves, de uma forma muito semelhante ao de hash de tabela.

1076
01:11:27,180 --> 01:11:30,880
Se você se lembrar de que, quando você iria colocar em uma string você pode tirar algo

1077
01:11:30,880 --> 01:11:33,840
que tem um valor associado com ele.

1078
01:11:33,840 --> 01:11:36,360
O que você pode fazer com isso é que você pode dizer, tudo bem,

1079
01:11:36,360 --> 01:11:42,120
Eu coloquei em um carro, e eu chamei-lhe um Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Então você pode colocar na cadeia de Ferrari novamente mais tarde, e você pode tirar isso.

1081
01:11:45,290 --> 01:11:50,000
E você pode fazer isso em um loop, com o no loop.

1082
01:11:50,000 --> 01:11:53,320
Então, só mais sobre objetos. A principal coisa a partir desta é preciso lembrar

1083
01:11:53,320 --> 01:12:00,340
é que você pode usar o objeto struct como sintaxe sempre que quiser com estes,

1084
01:12:00,340 --> 01:12:04,590
exceto se o que você vai usar como uma string não é um nome de variável válido.

1085
01:12:04,590 --> 01:12:07,650
Então, se você olhar para isso aí, temos chave com espaços.

1086
01:12:07,650 --> 01:12:12,500
Bem, se você fosse para colocar object.key, espaço, com, espaço, espaços,

1087
01:12:12,500 --> 01:12:15,320
que simplesmente não faria sentido sintaticamente.

1088
01:12:15,320 --> 01:12:22,730
Assim, você só pode fazer isso com este tipo de sintaxe suporte.

1089
01:12:22,730 --> 01:12:26,520
>> Além disso, JavaScript é muito âmbito-wise para PHP.

1090
01:12:26,520 --> 01:12:29,050
Você tem duas formas de abordar escopo.

1091
01:12:29,050 --> 01:12:31,960
Você não pode ter o var na frente de uma variável,

1092
01:12:31,960 --> 01:12:34,060
e isso apenas significa que este é global.

1093
01:12:34,060 --> 01:12:37,050
Você pode vê-lo de qualquer lugar. Mesmo se você colocar isso em uma instrução if,

1094
01:12:37,050 --> 01:12:42,430
em qualquer outro lugar no seu código depois desse ponto, você poderia ver essa variável.

1095
01:12:42,430 --> 01:12:46,730
Outra coisa, porém, é com a var, é limitada a qualquer função que você está dentro

1096
01:12:46,730 --> 01:12:48,870
Se você não estiver em uma função, bem, é global.

1097
01:12:48,870 --> 01:12:53,900
Mas se você estiver em uma função é apenas visível dentro dessa função.

1098
01:12:53,900 --> 01:12:56,420
Eu não tenho um exemplo, mas, sim. É uma daquelas coisas onde

1099
01:12:56,420 --> 01:12:59,900
você pode gerenciar o que as variáveis ​​que você quer ser global,

1100
01:12:59,900 --> 01:13:03,810
que as variáveis ​​que você quer ser local, mas você precisa ter cuidado com isso,

1101
01:13:03,810 --> 01:13:06,890
porque você não tem o tipo de controle de grão fino que você faz em C,

1102
01:13:06,890 --> 01:13:15,820
onde se algo é declarado em um loop for, ele vai ficar nesse loop for.

1103
01:13:15,820 --> 01:13:18,790
A única coisa que realmente se preocupam com o uso de JavaScript é a manipulação de páginas web, certo?

1104
01:13:18,790 --> 01:13:21,800
Quero dizer, é por isso que estamos fazendo isso.

1105
01:13:21,800 --> 01:13:23,840
>> Para fazer isso, usamos algo chamado DOM.

1106
01:13:23,840 --> 01:13:25,850
O Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
Basicamente, o que ele faz é que leva todo o seu HTML

1108
01:13:29,430 --> 01:13:34,110
e modelos lo para fora em um monte de objetos que são aninhados uns dentro dos outros.

1109
01:13:34,110 --> 01:13:37,080
Você começa com algo como isto.

1110
01:13:37,080 --> 01:13:44,770
Você tem, por certo, para mim, um monte de código lá fora, que é uma espécie de -

1111
01:13:44,770 --> 01:13:46,640
Você poderia pensar que seria muito difícil de manipular,

1112
01:13:46,640 --> 01:13:48,700
porque você estaria analisando através de um monte de texto

1113
01:13:48,700 --> 01:13:52,080
e ter a peça à parte as coisas. E se não foi formatado corretamente?

1114
01:13:52,080 --> 01:13:54,880
Coisas ruins aconteceriam.

1115
01:13:54,880 --> 01:13:58,140
Então JavaScript cuida disso para você, e você terá uma estrutura de dados bom,

1116
01:13:58,140 --> 01:14:01,390
como a que à minha esquerda, onde você só tem um documento,

1117
01:14:01,390 --> 01:14:03,530
e dentro de que você tem algo chamado HTML,

1118
01:14:03,530 --> 01:14:05,600
e dentro de que você tem uma cabeça e um corpo,

1119
01:14:05,600 --> 01:14:08,420
e dentro dessa cabeça que você tem um título, etc, etc, etc.

1120
01:14:08,420 --> 01:14:11,810
Isso simplifica a manipulação de uma página da web para que seja justo,

1121
01:14:11,810 --> 01:14:14,190
oh, eu só quero falar com esse objeto.

1122
01:14:14,190 --> 01:14:21,340
Espécie de uma forma muito semelhante você falaria para outro objeto que você fez a si mesmo.

1123
01:14:21,340 --> 01:14:25,980
Como eu disse, tudo o DOM é o objeto de documento.

1124
01:14:25,980 --> 01:14:29,290
Ou é apenas um lugar e então você pode ir dentro dele para encontrar as coisas,

1125
01:14:29,290 --> 01:14:33,880
e você pode fazê-lo - este é o velho estilo de fazer isso, lá em cima,

1126
01:14:33,880 --> 01:14:38,130
onde você faz document.getElementById, e, em seguida, o nome,

1127
01:14:38,130 --> 01:14:42,420
e como você provavelmente pode dizer, isso fica muito pesado depois de um tempo.

1128
01:14:42,420 --> 01:14:44,480
Então você provavelmente não quer fazer isso. É por isso que nós temos

1129
01:14:44,480 --> 01:14:48,760
a próxima coisa que nós vamos falar sobre isso depois.

1130
01:14:48,760 --> 01:14:52,510
O importante aqui é que, tudo bem, você tem todos esses elementos, certo?

1131
01:14:52,510 --> 01:14:56,400
Então talvez eu possa mudar a cor de alguma coisa quando a página é carregada.

1132
01:14:56,400 --> 01:14:58,380
Então o que? E se o meu usuário clica em alguma coisa?

1133
01:14:58,380 --> 01:15:00,540
Eu quero que ele faça algo interessante quando clicam alguma coisa.

1134
01:15:00,540 --> 01:15:02,600
É por isso que temos eventos.

1135
01:15:02,600 --> 01:15:05,330
Você pode, basicamente, encontrar qualquer elemento em seu DOM,

1136
01:15:05,330 --> 01:15:08,560
e depois dizer, hey. Quando este carrega ou alguém clica nele,

1137
01:15:08,560 --> 01:15:11,410
ou quando do mouse sobre ele, fazer algo com ele.

1138
01:15:11,410 --> 01:15:15,330
E o que você tem é, você tem funções que lidam com isso para você.

1139
01:15:15,330 --> 01:15:17,980
Estas funções são manipuladores de eventos.

1140
01:15:17,980 --> 01:15:20,440
O que eles - que é apenas uma maneira elegante de dizer,

1141
01:15:20,440 --> 01:15:23,500
esta função só é executada quando o evento acontece.

1142
01:15:23,500 --> 01:15:28,070
Então, ele lida com o evento que ocorre.

1143
01:15:28,070 --> 01:15:30,810
Isto é como você colocar para fora um manipulador de eventos.

1144
01:15:30,810 --> 01:15:34,750
Tenho alguma tecla, e quando você clicar nele, ele explode.

1145
01:15:34,750 --> 01:15:40,560
Portanto, não clique no botão.

1146
01:15:40,560 --> 01:15:42,910
Esta é uma maneira de abordá-lo, certo?

1147
01:15:42,910 --> 01:15:46,430
Você tem uma marca de botão e clique em que você tem uma seqüência que diz:

1148
01:15:46,430 --> 01:15:50,460
oh, a propósito, eu faço essa coisa explodindo para mim.

1149
01:15:50,460 --> 01:15:53,990
Caso contrário, é como um botão regular, você acabou de fazer.

1150
01:15:53,990 --> 01:15:56,550
Você também pode fazer isso de outra forma,

1151
01:15:56,550 --> 01:16:02,770
agarrando o elemento DOM, mas vamos guardar isso depois falamos sobre jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: É uma biblioteca que é cross-browser.

1153
01:16:07,580 --> 01:16:09,580
Você pode usá-lo em praticamente qualquer coisa.

1154
01:16:09,580 --> 01:16:12,090
E isso só lhe dá um monte de ferramentas para trabalhar.

1155
01:16:12,090 --> 01:16:15,850
Porque JavaScript, enquanto poderoso, não tem todas as ferramentas que você precisa

1156
01:16:15,850 --> 01:16:20,550
fora da caixa para realmente enfrentar uma aplicação web que você pode querer fazer.

1157
01:16:20,550 --> 01:16:24,650
Assim, ele simplifica um monte de coisas, dá-lhe um monte de funções

1158
01:16:24,650 --> 01:16:28,760
fora da caixa que você normalmente tem que escrever mesmo, uma e outra e outra vez.

1159
01:16:28,760 --> 01:16:31,600
E só torna as coisas muito simples.

1160
01:16:31,600 --> 01:16:35,780
Você também tem seletores, que permitem que você tirar todos esses elementos

1161
01:16:35,780 --> 01:16:42,800
de seu DOM muito mais simples, em vez de ter que usar essas chamadas de função muito longos.

1162
01:16:42,800 --> 01:16:46,630
Mais informações sobre esses seletores. Você tem, lá em cima você tem, digamos

1163
01:16:46,630 --> 01:16:49,800
Eu quero começar um elemento com o ID "rock".

1164
01:16:49,800 --> 01:16:56,450
Bem, em jQuery, que é de apenas US $ e, em seguida, uma seqüência que tenha um quilo, e, em seguida, "rock".

1165
01:16:56,450 --> 01:17:01,960
É muito simples e muito mais rápido do que a maneira tradicional de JavaScript resolução deste problema.

1166
01:17:01,960 --> 01:17:06,120
E você tem coisas semelhantes para as classes e tipos de elementos.

1167
01:17:06,120 --> 01:17:08,140
jQuery é - um dos recursos interessantes é que você pode classificar de comprimir

1168
01:17:08,140 --> 01:17:14,350
as suas dúvidas sobre o seu DOM muito, muito rápido.

1169
01:17:14,350 --> 01:17:18,980
Agora estamos de volta para o tratamento de eventos, e isso é como você lidaria com um evento em jQuery.

1170
01:17:18,980 --> 01:17:23,090
Então, o que vamos aqui é que estamos dizendo, tudo bem. Eu tenho uma tag script, certo?

1171
01:17:23,090 --> 01:17:25,400
Então, eu tenho essa linha JavaScript.

1172
01:17:25,400 --> 01:17:27,750
O que nós vamos fazer é que vai dizer, tudo bem.

1173
01:17:27,750 --> 01:17:30,860
Quando o documento estiver pronto, o que significa que o documento foi carregado,

1174
01:17:30,860 --> 01:17:34,660
estamos indo para ir a essa função, e vamos dizer, tudo bem,

1175
01:17:34,660 --> 01:17:37,060
esta função está realmente fazendo alguma outra coisa.

1176
01:17:37,060 --> 01:17:42,320
É basicamente dizendo, tudo bem, me o elemento com o ID "myid".

1177
01:17:42,320 --> 01:17:47,960
E, em seguida, dar a este um manipulador função que é executado quando você clica nele.

1178
01:17:47,960 --> 01:17:49,820
Basicamente o que isto significa é, diz, tudo bem.

1179
01:17:49,820 --> 01:17:52,630
A página é carregada, por isso estou indo para dentro, encontrar este elemento,

1180
01:17:52,630 --> 01:17:56,420
dar-lhe esse manipulador de eventos, e que basicamente define a sua página para você.

1181
01:17:56,420 --> 01:18:00,520
E é assim que você quer pensar sobre a manipulação de eventos.

1182
01:18:00,520 --> 01:18:06,310
Você só quer pensar, tudo bem, quando ocorre alguma coisa, o que eu quero que aconteça?

1183
01:18:06,310 --> 01:18:10,520
Você não quer pensar, tudo bem, eu preciso ter certeza de que esta coisa fala com essa coisa,

1184
01:18:10,520 --> 01:18:14,660
essa coisa de blá blá blá, porque você só quer falar coisa em termos de eventos.

1185
01:18:14,660 --> 01:18:17,650
Quando isto acontece, isso acontece. Quando isso acontece, o que acontece.

1186
01:18:17,650 --> 01:18:20,240
E se as coisas desencadear outras coisas, isso é ótimo.

1187
01:18:20,240 --> 01:18:22,150
Mas você não quer tentar fazer código complicado

1188
01:18:22,150 --> 01:18:24,130
onde você está provocando várias coisas ao mesmo tempo,

1189
01:18:24,130 --> 01:18:28,860
porque você está indo só para dar-se uma dor de cabeça.

1190
01:18:28,860 --> 01:18:32,340
>> Tudo bem. Agora podemos começar a nossa página de lidar com eventos,

1191
01:18:32,340 --> 01:18:35,640
mas digamos que o meu usuário clica em um botão.

1192
01:18:35,640 --> 01:18:38,040
E se eu quiser enviar o pedido de volta ao servidor,

1193
01:18:38,040 --> 01:18:41,100
mas eu não quero recarregar a página, porque ter que recarregar uma nova página

1194
01:18:41,100 --> 01:18:44,390
cada vez que fica meio entediante, e por que eu preciso

1195
01:18:44,390 --> 01:18:47,430
para puxar para baixo o cabeçalho de novo, e de novo o rodapé,

1196
01:18:47,430 --> 01:18:49,670
e todos os elementos da página de novo

1197
01:18:49,670 --> 01:18:53,180
só para refrescar o cumprimento ou o tempo todo?

1198
01:18:53,180 --> 01:18:55,290
Então é por isso que temos algo como Ajax.

1199
01:18:55,290 --> 01:18:59,150
O que podemos fazer aqui com Ajax é que podemos dizer, tudo bem,

1200
01:18:59,150 --> 01:19:01,290
Eu quero enviar alguns dados para o servidor,

1201
01:19:01,290 --> 01:19:04,010
e eu quero ter uma resposta de volta para que eu possa atualizar minha página,

1202
01:19:04,010 --> 01:19:12,120
ou talvez apenas fazer alguns cálculos algorítmicos que não necessariamente mostrar nada para o usuário.

1203
01:19:12,120 --> 01:19:15,500
O que você precisa fazer isso? Bem, você precisa de um URL que você precisa para conversar.

1204
01:19:15,500 --> 01:19:18,650
O servidor não pode magicamente ouvir do nada.

1205
01:19:18,650 --> 01:19:21,960
Você precisa ter um lugar específico que você está enviando os dados para.

1206
01:19:21,960 --> 01:19:26,240
E você também precisa de alguns dados para enviar, ou talvez seja uma consulta sem dados.

1207
01:19:26,240 --> 01:19:31,380
Você só quer fazer o ping de volta para o servidor e dizer: ei, eu estou vivo, ou algo parecido.

1208
01:19:31,380 --> 01:19:35,150
E então você quer uma função que lida basicamente com sucesso.

1209
01:19:35,150 --> 01:19:38,250
Vamos dizer que você receber de volta algumas informações do seu servidor,

1210
01:19:38,250 --> 01:19:42,960
e você quer mudar o título do usuário em sua página.

1211
01:19:42,960 --> 01:19:44,930
Assim, você terá a informação de volta,

1212
01:19:44,930 --> 01:19:48,860
e você teria que empurrar para a tela.

1213
01:19:48,860 --> 01:19:51,170
O que acontece é que, quando a página está pronta,

1214
01:19:51,170 --> 01:19:56,500
você criar um em função de clique para este botão chamado saudação.

1215
01:19:56,500 --> 01:19:58,810
O que isto faz é então, quando esse botão é pressionado,

1216
01:19:58,810 --> 01:20:03,700
você fala com greetings.php, você faz uma solicitação POST,

1217
01:20:03,700 --> 01:20:07,290
e você diz, hey, me algo de sua página.

1218
01:20:07,290 --> 01:20:09,890
Nós realmente não precisa descrever isso, mas greetings.php,

1219
01:20:09,890 --> 01:20:12,480
vamos apenas dizer, dá de volta "Olá mundo".

1220
01:20:12,480 --> 01:20:15,650
Assim que voltarmos este "Olá mundo", e no sucesso deste,

1221
01:20:15,650 --> 01:20:20,730
assumindo nada der errado, então basta ir a este lugar-alvo

1222
01:20:20,730 --> 01:20:25,720
que nós especificamos e se ater apenas a resposta lá.

1223
01:20:25,720 --> 01:20:31,560
E esta é uma maneira muito simples de configurar uma consulta Ajax.

1224
01:20:31,560 --> 01:20:34,340
>> Muito rapidamente, Rob tipo de mencionado isso já,

1225
01:20:34,340 --> 01:20:37,170
as coisas podem dar errado, coisas ruins podem acontecer,

1226
01:20:37,170 --> 01:20:42,660
assim que você quer para se familiarizar com esses códigos de resposta HTTP.

1227
01:20:42,660 --> 01:20:46,030
O que são estes são apenas, como, 200, tudo correu bem.

1228
01:20:46,030 --> 01:20:48,670
Outra coisa, as coisas ruins aconteceram.

1229
01:20:48,670 --> 01:20:50,790
Em geral, é a coisa que você quer se lembrar.

1230
01:20:50,790 --> 01:20:53,440
Mas é bom saber que todos estes.

1231
01:20:53,440 --> 01:20:55,970
E, finalmente, uma vez que já passou por tudo isso,

1232
01:20:55,970 --> 01:20:58,680
precisamos falar muito rapidamente sobre o projeto,

1233
01:20:58,680 --> 01:21:00,620
e então podemos deixar que todos sair.

1234
01:21:00,620 --> 01:21:03,410
Projeto. Coisas que você quer se lembrar.

1235
01:21:03,410 --> 01:21:06,950
Pergunte a si mesmo estas perguntas: Quem vai usar isso?

1236
01:21:06,950 --> 01:21:09,580
O que eles vão usá-lo para? O que meus usuários se preocupam?

1237
01:21:09,580 --> 01:21:11,750
O que não se preocupam?

1238
01:21:11,750 --> 01:21:14,500
Você só não quer fazer um aplicativo e deixá-lo apenas crescer

1239
01:21:14,500 --> 01:21:18,270
e tornar-se este gigante, que tudo consome coisa que você não pode mesmo terminar.

1240
01:21:18,270 --> 01:21:23,900
Você quer ter objetivos distintos planos e coisas que você quer abordar.

1241
01:21:23,900 --> 01:21:29,000
Torná-lo sem esforço. Tudo isso, diz, basicamente,

1242
01:21:29,000 --> 01:21:34,950
tornar mais fácil para o usuário a utilizá-la, não torná-lo uma bolha gigante de texto como este slide é, na verdade.

1243
01:21:34,950 --> 01:21:38,020
Você só quer que ele seja algo que é muito fácil para alguém para ir em

1244
01:21:38,020 --> 01:21:40,800
e fazer o que eles querem fazer.

1245
01:21:40,800 --> 01:21:42,920
Você não quer que eles tenham para navegar 5 páginas

1246
01:21:42,920 --> 01:21:45,460
para chegar ao seu principal função do seu site.

1247
01:21:45,460 --> 01:21:49,290
Se o Google tinha 5 páginas antes mesmo que pudesse pesquisar alguma coisa,

1248
01:21:49,290 --> 01:21:53,080
ninguém iria usá-lo.

1249
01:21:53,080 --> 01:21:55,890
E, por último, o protótipo de papel, grupo focal.

1250
01:21:55,890 --> 01:21:59,220
Tenha um bom design e práticas de teste.

1251
01:21:59,220 --> 01:22:00,730
Só porque você acha que ele funciona para você,

1252
01:22:00,730 --> 01:22:04,860
não significa que os outros pensam que funciona.

1253
01:22:04,860 --> 01:22:14,490
Mas sim, é isso.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]