1
00:00:00,590 --> 00:00:02,100
Bem-vindo de volta.

2
00:00:02,100 --> 00:00:04,480
Então, esta lição é completamente opcional.

3
00:00:04,770 --> 00:00:06,660
É um pouco um bônus.

4
00:00:06,690 --> 00:00:09,810
É realmente algo que é um pouco interessante.

5
00:00:09,840 --> 00:00:13,080
É por isso que estou mostrando para você, mas não é essencial para o curso.

6
00:00:13,080 --> 00:00:18,360
E vamos falar sobre o funcionamento do foreach e vamos construir nossa própria versão para cada um.

7
00:00:18,690 --> 00:00:23,130
Então, vamos falar sobre como você escreve uma função que assume uma função como um argumento

8
00:00:23,250 --> 00:00:25,470
e, em seguida, executa essa função dentro dela.

9
00:00:25,470 --> 00:00:27,620
Então, novamente, completamente opcional.

10
00:00:27,720 --> 00:00:32,880
A outra razão para torná-lo opcional é que é um pouco mais avançado e não quero

11
00:00:32,940 --> 00:00:38,760
intimidar todos, eu não quero que você se sinta mal, se é confuso para você porque é confuso

12
00:00:38,760 --> 00:00:41,250
e, muitas vezes, é preciso repetições múltiplas disto.

13
00:00:41,490 --> 00:00:42,790
Para os meus alunos obtê-lo.

14
00:00:42,960 --> 00:00:44,350
Então é totalmente opcional.

15
00:00:44,550 --> 00:00:48,540
E isso é importante, mas não é essencial para fazer aplicativos.

16
00:00:48,630 --> 00:00:51,310
Não é essencial avançar no curso.

17
00:00:51,330 --> 00:00:55,500
É, porém, algo que, se você tentar assistir uma vez e não faz uma boa sensação para

18
00:00:55,820 --> 00:01:00,280
você, você poderia voltar para o final da aula, uma vez que você tenha mais alguma experiência de Javascript.

19
00:01:00,330 --> 00:01:03,490
E isso também é algo que eu tenho que fazer com meus estudantes pessoalmente o tempo todo.

20
00:01:03,570 --> 00:01:06,080
Como mencionei, revisamos este tópico.

21
00:01:06,210 --> 00:01:11,310
Então, vamos começar, vamos construir o nosso próprio para cada um e vamos começar por

22
00:01:12,120 --> 00:01:17,160
definir uma função chamada para cada um e vai funcionar um pouco diferente do

23
00:01:17,160 --> 00:01:23,800
que o verdadeiro foreach funciona, agora mesmo do jeito que Para cada obra é que eu defino uma matriz,

24
00:01:23,810 --> 00:01:27,660
vamos chamar Nom's e teremos alguns números lá da mesma forma.

25
00:01:28,050 --> 00:01:30,390
E eu chamo para cada um em Nomes.

26
00:01:30,480 --> 00:01:37,770
Então, nums ponto para cada um e depois eu dou uma função e acabamos de ver isso, então não

27
00:01:37,770 --> 00:01:44,820
vou aborrecê-lo com muita esperança, mas vamos chamar esse número e depois fazer um registro simples e constante.

28
00:01:45,240 --> 00:01:46,160
Não.

29
00:01:46,800 --> 00:01:49,030
Aqui vamos nós.

30
00:01:49,260 --> 00:01:54,580
É preciso uma função e chama uma função em cada elemento da matriz.

31
00:01:54,740 --> 00:01:59,130
Knops, mas note que não precisamos passar Nom's para cada um.

32
00:01:59,190 --> 00:02:04,680
Sabia apenas sobre os números que conhecia sobre a matriz porque fizemos o ponto de Gnome para cada um.

33
00:02:04,680 --> 00:02:07,740
Então, não vamos começar definindo uma função que funciona desse jeito.

34
00:02:07,830 --> 00:02:09,810
Vamos começar com um que se parece com isso.

35
00:02:09,990 --> 00:02:16,560
Bem, chame isso para cada um e, ao invés de tomar apenas um argumento, levará dois.

36
00:02:16,710 --> 00:02:21,870
E a primeira é a matriz e a segunda é a função.

37
00:02:21,870 --> 00:02:24,390
Então array será Nomes.

38
00:02:24,450 --> 00:02:25,880
E esta seria a função.

39
00:02:26,010 --> 00:02:33,270
Então, se você quisesse executar o mesmo código com Nom's, ficaria assim com a minha vírgula de

40
00:02:33,270 --> 00:02:39,590
cada Nom e, em seguida, toda a nossa função aqui, que se parecerá o mesmo.

41
00:02:39,600 --> 00:02:42,560
Então estamos começando com esta versão porque é mais simples.

42
00:02:43,080 --> 00:02:46,310
É um pouco mais de sintaxe, mas é mais simples para nós escrever.

43
00:02:46,590 --> 00:02:52,350
Então, novamente, estamos passando em Nome, em vez de apenas agarrá-lo usando mágica especial de javascript.

44
00:02:52,350 --> 00:02:57,600
Há uma maneira de agarrá-lo se você estiver definindo um método em algo como nós temos aqui, mas vamos chegar a

45
00:02:57,600 --> 00:02:57,950
isso.

46
00:02:58,110 --> 00:03:02,520
OK então vamos definir uma função MYF ou cada uma.

47
00:03:02,940 --> 00:03:06,150
E é preciso uma matriz e uma função.

48
00:03:06,150 --> 00:03:10,560
E não podemos chamar essa função porque essa é uma palavra especial em Javascript.

49
00:03:10,560 --> 00:03:16,840
Então, chamaremos phunk ou F o que quer que você queira chamar e depois abriremos nossa função.

50
00:03:17,520 --> 00:03:20,830
E vamos começar por falar sobre o que para cada um faz.

51
00:03:21,210 --> 00:03:27,460
Então lembre-se que leva essa função e chama isso para cada item na matriz.

52
00:03:27,480 --> 00:03:32,390
Então, para fazer isso, precisamos usar um loop para fazer qualquer coisa por cada item em uma matriz.

53
00:03:32,400 --> 00:03:33,730
Temos que ter um loop.

54
00:03:33,780 --> 00:03:40,200
Então, vamos usar apenas um loop for loop loop e depois no loop, vamos apenas chamar de função

55
00:03:40,230 --> 00:03:45,570
e tudo o que precisamos fazer para chamar a função é adicionar parênteses ao final.

56
00:03:45,810 --> 00:03:51,300
isso é o que meus alunos sempre lutam e quem está aprendendo javascript é desligado aqui.

57
00:03:51,300 --> 00:03:52,800
Então, é um pouco confuso,

58
00:03:52,950 --> 00:03:58,060
Mas lembre-se da distinção entre o nome de uma função sem parênteses.

59
00:03:58,740 --> 00:04:00,960
Isso apenas se refere à própria função.

60
00:04:01,050 --> 00:04:07,740
Mas não está executando isso assim que eu adicionar os parênteses, esse código em vez de funcionar

61
00:04:07,740 --> 00:04:08,320
e executá-lo.

62
00:04:08,670 --> 00:04:10,480
Então eu posso dar um exemplo aqui.

63
00:04:10,710 --> 00:04:11,860
Se acabamos de fazer.

64
00:04:12,010 --> 00:04:13,310
Deixe-me cortar isso.

65
00:04:13,530 --> 00:04:17,610
Se apenas alertar alertas não é executado.

66
00:04:17,760 --> 00:04:20,690
Mas, assim que adicionamos esses parênteses, recebemos um alerta.

67
00:04:20,820 --> 00:04:24,200
E eu não passei nada, mas ainda é executado o código.

68
00:04:24,780 --> 00:04:31,170
Então, vamos voltar ao nosso código e, ao invés de apenas chamar phunk imediatamente, seguiremos

69
00:04:31,170 --> 00:04:31,790
a matriz.

70
00:04:31,830 --> 00:04:43,490
Então adiciono um loop de comentário através da matriz e, em seguida, dentro da chamada de loop phunk para cada item na matriz.

71
00:04:43,560 --> 00:04:45,360
Então, para percorrer a matriz.

72
00:04:46,080 --> 00:04:47,250
Bem, este é um loop for.

73
00:04:47,280 --> 00:04:50,260
Você também pode usar um loop while, mas usaremos um loop for.

74
00:04:50,280 --> 00:04:58,050
Então, para var eu igual zero I menos do que um r r ponto comprimento que é o nome do argumento.

75
00:04:58,140 --> 00:04:59,590
A R R.

76
00:04:59,880 --> 00:05:01,170
E então eu

77
00:05:04,640 --> 00:05:13,760
mais mais, assim como isso, e então vou mudar essa linha para o nosso loop, porque o que queremos fazer é

78
00:05:13,760 --> 00:05:20,050
dentro deste loop, queremos chamar phunk para que possamos começar apenas ligando para pessoas assim.

79
00:05:20,840 --> 00:05:26,900
seja passada, pois o segundo argumento será chamado uma vez por cada item da matriz, ainda faltamos

80
00:05:26,900 --> 00:05:32,060
uma peça importante que é realmente passar os dados de cada item na matriz.

81
00:05:32,060 --> 00:05:33,250
Então, qualquer função

82
00:05:33,320 --> 00:05:35,360
Mas toda essa coluna para cada item.

83
00:05:35,360 --> 00:05:36,680
Então, vamos entrar.

84
00:05:37,420 --> 00:05:38,920
E agora vamos tentar executar isso.

85
00:05:38,930 --> 00:05:46,780
Eu vou definir uma matriz chamada cores ou favorito meu favorito pelo menos laranja.

86
00:05:46,910 --> 00:05:48,640
E nós vamos parar em amarelo.

87
00:05:49,160 --> 00:05:58,040
Então, três itens e então eu vou chamar meus quatro cada e passar em cores como a matriz e então eu

88
00:05:58,640 --> 00:05:59,910
vou apenas alertar.

89
00:06:00,110 --> 00:06:04,430
E não adicionamos parênteses, lembre-se porque isso irá executar imediatamente o alerta.

90
00:06:04,430 --> 00:06:05,580
Isso não é o que queremos.

91
00:06:06,170 --> 00:06:10,980
Queremos que a função seja minha para que cada um seja o único a executar o alerta.

92
00:06:11,180 --> 00:06:13,600
Então lembre-se que phunk está realmente alerta.

93
00:06:13,610 --> 00:06:20,900
Neste caso, mas também pode ser cônsul que logar ou, na maioria das vezes, seria uma função anônima.

94
00:06:20,900 --> 00:06:24,740
Nós definimos que seria chamado Inside of phunk.

95
00:06:24,800 --> 00:06:29,480
Então, vamos mudá-lo de volta ao alerta e entra em cena.

96
00:06:29,900 --> 00:06:31,340
Recebo um alerta.

97
00:06:31,730 --> 00:06:34,430
Acerto OK. Recebo outro alerta.

98
00:06:34,640 --> 00:06:37,320
Eu bati OK e recebo mais um alerta.

99
00:06:37,670 --> 00:06:43,640
Então, o que está acontecendo é que este loop é looping array, que no nosso caso é uma série de

100
00:06:43,640 --> 00:06:44,900
cores com três itens.

101
00:06:44,900 --> 00:06:51,520
Então, três vezes é loops e cada vez que chama func e tudo o que phunk está está alerta.

102
00:06:51,560 --> 00:06:52,670
Isso é tudo o que é.

103
00:06:52,670 --> 00:06:57,980
Então alerta um alerta vazio três vezes porque não estamos passando nada para o funk.

104
00:06:57,980 --> 00:07:05,000
func é tudo o que fazemos é passar um pouco de dados aqui e que um pouco de dados deve ser cada item na matriz.

105
00:07:05,000 --> 00:07:10,240
Então, para fazê-lo funcionar com os dados que estão sendo transmitidos para alerta ou o que quer que

106
00:07:10,250 --> 00:07:13,190
Então, a maneira como acessamos cada item é usando I.

107
00:07:13,370 --> 00:07:19,810
Então, se eu recordar o código aqui, eu apenas adiciono um suporte de matriz.

108
00:07:20,860 --> 00:07:25,100
Então, pela primeira vez no loop, isso chamará de função que esteja alerta.

109
00:07:25,100 --> 00:07:32,230
Nesse caso, com o primeiro item na matriz que é lido, então o alerta será lido e então eu

110
00:07:32,240 --> 00:07:33,240
me tornarei um.

111
00:07:33,320 --> 00:07:38,510
Então, lembre-se de Phunk, que ainda está alerta com um array de um que é laranja.

112
00:07:38,510 --> 00:07:46,340
vez, o alerta de amarelo diz, então veja isso agora mesmo se eu recordar minha execução aqui para o alerta de cada cor.

113
00:07:46,700 --> 00:07:49,840
Então, ficamos alertas laranja e, em seguida, mais uma

114
00:07:50,420 --> 00:07:58,500
Agora me dá vermelho laranja e amarelo e na verdade é tudo o que há para definir para cada um.

115
00:07:58,580 --> 00:08:04,190
No entanto, como eu disse a maior parte do tempo, você não vai ver isso assim que passamos uma

116
00:08:04,190 --> 00:08:06,270
função chamada, geralmente terá uma função anônima.

117
00:08:06,320 --> 00:08:07,620
Então não vamos dar uma chance.

118
00:08:07,730 --> 00:08:09,920
Mas usando uma função anônima.

119
00:08:09,920 --> 00:08:17,390
Então, meu para cada e depois vamos passar e cores novamente e depois uma função anônima.

120
00:08:17,390 --> 00:08:22,670
parênteses aqui, são parênteses muito diferentes do que o referido, invoca uma função.

121
00:08:22,670 --> 00:08:25,270
E lembre-se de que, embora existam

122
00:08:25,280 --> 00:08:27,050
Então, deixe-me mostrar o que quero dizer.

123
00:08:27,470 --> 00:08:33,050
Se eu excluir esta primeira parte e eu apenas tenho uma função anônima aqui.

124
00:08:33,410 --> 00:08:35,610
E tudo o que fazemos dentro é um diálogo de conselhos.

125
00:08:35,790 --> 00:08:43,130
Eu sou uma função e acertei Enter agora mesmo e eu possuo um pouco para você, por isso é um pouco

126
00:08:43,130 --> 00:08:45,730
mais fácil ver o que está acontecendo.

127
00:08:45,770 --> 00:08:47,930
O que você acha que vai acontecer.

128
00:08:49,130 --> 00:08:50,750
Bem, é claro, isso aconteceu.

129
00:08:50,960 --> 00:08:54,540
Deixe-me voltar e adicionar os parênteses de encerramento para o meu log de ponto de conselho.

130
00:08:54,740 --> 00:08:56,360
Agora, o que você acha que vai acontecer?

131
00:08:56,360 --> 00:08:58,910
Acho que é ruim o momento aqui.

132
00:08:59,150 --> 00:09:03,100
Mas quando acertei Enter, você verá que nada realmente acontece.

133
00:09:03,110 --> 00:09:06,200
Recebo um valor que me devolveu um valor que foi enviado de volta.

134
00:09:06,200 --> 00:09:12,380
Mas o código não é executado Eu não vejo perspectivas constantes e é porque essa função anônima

135
00:09:12,380 --> 00:09:13,620
nunca foi invocada.

136
00:09:13,670 --> 00:09:16,040
Basicamente, existia por um momento e agora desapareceu.

137
00:09:16,040 --> 00:09:16,960
Não lhe dei um nome.

138
00:09:16,970 --> 00:09:18,450
Não o guardei em uma variável.

139
00:09:18,500 --> 00:09:21,530
Eu nunca posso chamá-lo novamente, a menos que eu reescreva isso.

140
00:09:21,530 --> 00:09:26,240
Então, para executar esta função, eu ainda preciso desses parênteses depois.

141
00:09:26,240 --> 00:09:29,700
Então, esta é uma grande sintaxe, é um pouco feio na minha opinião.

142
00:09:29,810 --> 00:09:33,490
Mas agora, se eu tivesse esses parênteses, obtive a função.

143
00:09:33,830 --> 00:09:43,970
Então, é o mesmo quando fazemos isso meu para cada cor e depois passamos aqui uma função anônima.

144
00:09:45,520 --> 00:09:53,720
que esta função faz qualquer coisa, apenas digamos alertas, esta função não está sendo invocada aqui.

145
00:09:53,720 --> 00:09:55,020
E digamos

146
00:09:55,310 --> 00:09:56,860
Esta é a função aqui.

147
00:09:56,870 --> 00:10:00,120
Nós ainda precisamos desses parênteses depois, como nós, temos aqui.

148
00:10:00,520 --> 00:10:07,250
E isso vem de dentro do meu foreach, onde estamos adicionando esses parênteses ao funk e ao funk.

149
00:10:07,310 --> 00:10:10,540
No nosso caso, aqui é todo o segundo argumento.

150
00:10:10,610 --> 00:10:15,670
Então, se você está um pouco perdido nisso, não se preocupe novamente não é crucial para o resto do curso.

151
00:10:15,950 --> 00:10:22,300
Mas tente isso novamente mais tarde no final, então eu posso fazer algo assim, quando eu apenas alerta alto ou

152
00:10:22,310 --> 00:10:25,670
não estou realmente usando os dados como vermelho laranja e amarelo.

153
00:10:25,750 --> 00:10:29,010
Não é tão comum querer fazer isso, mas se eu entrar no enter.

154
00:10:29,570 --> 00:10:33,530
Você verá que eu consigo um alto alto e três altos.

155
00:10:33,560 --> 00:10:37,370
Então, para cada item na matriz dessa cor, existem três itens.

156
00:10:37,370 --> 00:10:43,490
Ele chama essa função inteira, mas na maioria das vezes o que queríamos fazer, é realmente usar essa cor

157
00:10:43,490 --> 00:10:44,940
como estamos fazendo aqui.

158
00:10:45,130 --> 00:10:47,160
Ou podemos começar como cada cor.

159
00:10:47,620 --> 00:10:50,920
Então, tudo o que temos a fazer é aceitar um argumento em nossa função.

160
00:10:51,010 --> 00:10:55,570
Então, meu foreach e isso está espaçado um pouco.

161
00:10:55,580 --> 00:11:02,480
Então, a função e isso será chamado de cor, mas isso pode ser qualquer coisa, claro, como qualquer outra

162
00:11:02,480 --> 00:11:03,450
função que definimos.

163
00:11:03,620 --> 00:11:08,810
Pode ser quase qualquer coisa que tem que ser um nome javascript válido, não pode ser

164
00:11:08,890 --> 00:11:13,800
algo como função ou var que são reservados para suas palavras-chave, mas qualquer outra coisa funcionará.

165
00:11:13,820 --> 00:11:15,110
Então é isso que temos aqui.

166
00:11:15,230 --> 00:11:20,820
Uma função anônima que agora está esperando um argumento e então podemos usá-lo dentro daqui.

167
00:11:20,840 --> 00:11:24,920
Então, conserve a cor do log de ponto para começar.

168
00:11:26,260 --> 00:11:30,640
Então, para percorrer isso, mais uma vez passamos as cores.

169
00:11:30,640 --> 00:11:37,280
Neste caso, isso é o que nossa matriz é um são, nós seguimos por isso que cada vez que

170
00:11:37,280 --> 00:11:40,600
estamos chamando phunk, que é essa coisa inteira aqui.

171
00:11:40,940 --> 00:11:45,770
Estou lembrando que, ao passar no item atual dessa matriz.

172
00:11:45,880 --> 00:11:48,280
Então estamos chamando este código aqui.

173
00:11:48,530 --> 00:11:51,760
E então estamos passando em vermelho e depois laranja e depois amarelo.

174
00:11:51,880 --> 00:11:54,950
Portanto, a cor é igual a vermelho, laranja ou amarelo.

175
00:11:54,950 --> 00:12:00,000
Toda vez que esta lista é exibida, ficamos vermelho laranja e amarelo.

176
00:12:00,160 --> 00:12:02,530
Então essa é a maneira básica de escrever para cada um.

177
00:12:02,870 --> 00:12:08,180
Mas, como uma promessa, eu também mostrava como nós somos adicionados a uma matriz para que possamos escrever como esse

178
00:12:08,430 --> 00:12:13,530
ponto de cores para cada um ou meu ponto para cada um, já que já existe para cada um.

179
00:12:13,660 --> 00:12:14,570
Vamos deixar isso sozinho.

180
00:12:14,650 --> 00:12:16,140
Mas coloque o meu para cada um.

181
00:12:16,120 --> 00:12:20,590
E então podemos passar uma função aqui para fazer isso.

182
00:12:20,960 --> 00:12:25,580
E quando um salto um pouco à frente de nós mesmos, nós não falamos sobre objetos, ainda não

183
00:12:25,790 --> 00:12:30,140
conversamos sobre protótipos, mas vou mostrar isso aqui e depois vamos aprender mais sobre isso, como o

184
00:12:30,130 --> 00:12:30,970
curso vai em.

185
00:12:30,980 --> 00:12:33,800
Na verdade, a próxima unidade é sobre objetos.

186
00:12:33,860 --> 00:12:40,750
Então, o que fazemos é que, na verdade, adicionamos um método para um tipo de produto de protótipo

187
00:12:43,370 --> 00:12:48,550
re dot, você nunca o soletra e chamaremos de meu para cada um.

188
00:12:48,560 --> 00:12:51,860
E antes que eu apresentei o autocompletar.

189
00:12:52,310 --> 00:12:55,640
Estes são todos os métodos que existem no protótipo da matriz.

190
00:12:55,630 --> 00:13:00,770
Então, é aí que nós conseguimos todos esses métodos como push e pop e deslocamos e

191
00:13:00,800 --> 00:13:07,580
não enviados e, para cada um que existe em cada matriz, eles são definidos no chamado protótipo da matriz e qualquer

192
00:13:07,580 --> 00:13:11,750
coisa definida nesse protótipo está disponível é utilizável em todas as matrizes .

193
00:13:12,380 --> 00:13:18,830
Então, vamos tentar isso agora ler protótipo do meu para cada um é uma função e a

194
00:13:21,630 --> 00:13:23,770
função só requer um argumento.

195
00:13:23,770 --> 00:13:32,870
Agora, como nós temos aqui, basta em função e, então, dentro, precisamos fazer nossa mesma lógica, onde roteamos a matriz e

196
00:13:32,870 --> 00:13:36,660
depois chamamos uma função para cada item na matriz.

197
00:13:36,680 --> 00:13:40,930
A única coisa que muda é que não estamos aceitando um argumento.

198
00:13:40,970 --> 00:13:45,410
A R, não temos mais a matriz, mas nós a temos aqui.

199
00:13:45,620 --> 00:13:47,030
É um pouco diferente.

200
00:13:47,090 --> 00:13:49,880
Temos que usar a palavra-chave.

201
00:13:50,030 --> 00:13:56,050
Então, a palavra-chave vai se referir à matriz particular que chamamos de Assan.

202
00:13:56,090 --> 00:14:03,590
Então, no caso das cores ponta para cada um se escrevemos a palavra-chave dentro de dentro para cada definição, ela

203
00:14:03,590 --> 00:14:04,950
se referiria às cores.

204
00:14:05,140 --> 00:14:08,350
Mas se fizéssemos números para cada coisa ou cão para cada um.

205
00:14:08,570 --> 00:14:12,530
Isso se refere à matriz específica na qual estamos ligando.

206
00:14:13,220 --> 00:14:19,980
Então, vamos fazer um quatro VAR I igual a zero.

207
00:14:20,210 --> 00:14:28,490
Enquanto eu é menor do que este ponto, eu gosto mais.

208
00:14:28,850 --> 00:14:30,490
Então essa é a primeira mudança.

209
00:14:30,500 --> 00:14:34,420
Usamos esse link que se refere à matriz específica.

210
00:14:34,610 --> 00:14:36,440
Então não estamos passando mais.

211
00:14:36,740 --> 00:14:44,240
A próxima coisa que fazemos é chamar phunk, tal como fizemos na versão original, exceto em vez

212
00:14:44,300 --> 00:14:48,160
do suporte de matriz, eu faria este suporte.

213
00:14:48,160 --> 00:14:51,480
Eu apenas gosto disso.

214
00:14:51,770 --> 00:14:53,140
E isso é realmente tudo o que há para isso.

215
00:14:53,140 --> 00:14:58,560
Então, acabamos de adaptá-lo um pouco, substituindo um r r, que tem o nome do nosso argumento.

216
00:14:58,580 --> 00:15:04,040
E poderia ter sido qualquer coisa, obviamente, substituindo-o pela palavra-chave.

217
00:15:04,120 --> 00:15:07,100
Então vamos tentar para usá-lo.

218
00:15:07,100 --> 00:15:08,520
Precisamos criar uma nova matriz.

219
00:15:08,650 --> 00:15:14,540
Então eu vou fazer um chamado amigos e nós teremos alguns amigos.

220
00:15:14,650 --> 00:15:16,790
Charlie.

221
00:15:18,020 --> 00:15:26,340
Dave Matie e Caitlin, assim como o hit, entram.

222
00:15:26,450 --> 00:15:33,290
Agora, podemos fazer amigos dot meus para cada um e que leva uma única função como um argumento.

223
00:15:33,400 --> 00:15:36,140
Então, podemos dar-lhe alerta se quisermos.

224
00:15:36,950 --> 00:15:38,090
E nós recebemos Charlie.

225
00:15:38,210 --> 00:15:46,800
Dave Madie e Caitlin, mas normalmente nós a veríamos com uma função anônima como essa, meu para cada

226
00:15:46,970 --> 00:15:54,090
uma e depois uma função aqui e digamos que cada uma delas é um nome.

227
00:15:54,110 --> 00:16:06,020
E então, o que nós faríamos é conosco, mas vamos fazer algo como o conselho que loguei eu amo o nome mais.

228
00:16:07,310 --> 00:16:09,560
Lá nós vamos e nós conseguimos.

229
00:16:09,560 --> 00:16:10,900
Eu amo Charlie, eu amo Dave.

230
00:16:10,940 --> 00:16:12,780
Eu amo Maddy. Eu amo Caitlin.

231
00:16:13,250 --> 00:16:15,030
OK, então é só isso.

232
00:16:15,320 --> 00:16:20,840
há muito, mas, no que diz respeito ao código, é realmente bastante curto apenas alguns novos conceitos.

233
00:16:20,840 --> 00:16:24,010
E não quero dizer que, de uma forma irreverente,

234
00:16:24,130 --> 00:16:28,290
Esse protótipo que eu realmente não passei e fiz isso de propósito.

235
00:16:28,660 --> 00:16:34,090
Não é importante agora se concentrar nisso, mas o que eu quero que você se concentre

236
00:16:34,100 --> 00:16:40,570
é essa idéia de passar uma função para que possamos passar uma função para um argumento ou como um

237
00:16:40,580 --> 00:16:47,060
argumento e não será executado Intel Inside the código em que nos referimos e adicione esses parênteses no final.

238
00:16:47,060 --> 00:16:50,230
Portanto, sem esses parênteses, a função não faz nada.

239
00:16:50,240 --> 00:16:50,810
Isso existe.

240
00:16:50,820 --> 00:16:56,560
É um valor que podemos fazer referência, mas nós adicionamos os parênteses e realmente é executado.

241
00:16:56,620 --> 00:16:57,650
Tudo bem, ótimo.

242
00:16:57,630 --> 00:16:59,890
Eu vejo na próxima unidade onde começamos a falar sobre objetos