0:00:00.387,0:00:04.096
Continuemos explorando o que [br]podemos fazer com objetos.

0:00:04.109,0:00:08.305
Voltamos para o programa que[br]usamos no tutorial de funções.

0:00:08.305,0:00:14.343
Este programa tem esta função <i>drawWinston</i>[br]que sabe desenhar Winston em certo X e Y.

0:00:14.521,0:00:16.441
E, aqui, chamamos <i>drawWinston</i>[br]

0:00:16.441,0:00:18.361
4 vezes, cada uma com um conjunto

0:00:18.361,0:00:21.521
diferente de coordenadas X e Y.

0:00:21.521,0:00:23.776
Bem, você me conhece, quando vejo

0:00:23.776,0:00:28.379
estas quatro chamadas para <i>drawWinton</i>[br]que se parecem tanto,

0:00:28.379,0:00:31.779
tudo que penso é: como seria[br]melhor se pudéssemos

0:00:31.779,0:00:36.329
usar um loop e chamá-la apenas [br]uma vez dentro do loop,

0:00:36.329,0:00:40.369
mudando X e Y em cada interação do loop.

0:00:40.369,0:00:47.036
Para isso, precisamos guardar esses X e Y[br]em um vetor para poder iterá-lo.

0:00:47.036,0:00:50.200
Bem, temos dois conjuntos de valores.

0:00:50.200,0:00:56.524
Então, poderíamos ter 2 vetores. Um para[br]a posição X e outro para a posição Y.

0:00:56.524,0:01:02.805
Nas posições X podemos ter [br]99, 294, 101 e 294,

0:01:02.805,0:01:09.946
e nas posições Y teremos[br]117, 117, 316, 316.

0:01:09.946,0:01:17.979
Ok, e agora podemos iterá-los com nosso loop[br]for var i = 0; i < xPositions.length; i++

0:01:17.979,0:01:22.174
Para cada elemento de[br]xPositions, dizemos

0:01:22.174,0:01:30.019
drawWinston ( xPositions[ i ],[br]yPositions [ i ] );

0:01:30.019,0:01:33.926
Ok, vejamos se funciona...[br]deletando...

0:01:33.926,0:01:36.200
Certo, funcionou!

0:01:36.200,0:01:40.459
Agora podemos apenas chamar [br]essa única linha de código que

0:01:40.459,0:01:45.518
executa drawWinston, mas o faz[br]para cada posição do vetor xPositions.

0:01:45.518,0:01:48.396
Podemos vir aqui e adicionar [br]mais a isso ... dizendo...

0:01:48.396,0:01:57.874
tipo 10, então adicionamos 1, e então 1, [br]e então 1, e então 100, e 1.

0:01:57.874,0:02:03.472
Agora... agora está ficando um pouco[br]confuso e não estou gostando,

0:02:03.472,0:02:09.914
porque está bem difícil ver que X[br]se relaciona com qual Y.

0:02:09.914,0:02:15.559
Eu quero poder apenas bater o olho e[br]saber quais são os pares X e Y,

0:02:15.559,0:02:22.454
ao invés de ter que garantir que os estou[br]alinhando corretamente, um sobre o outro

0:02:22.454,0:02:26.729
Preciso encontrar uma forma diferente[br]de armazenar essas posições.

0:02:26.729,0:02:30.791
Uma ideia é que poderíamos [br]armazená-las como objetos.

0:02:30.791,0:02:35.780
Pense nisso, cada posição é na verdade[br]duas informações: o X e o Y.

0:02:35.780,0:02:39.106
Então, poderíamos ter um objeto com as[br]propriedades X e Y,

0:02:39.106,0:02:44.002
e poderíamos ter um vetor -de objetos[br]com todas essas posições X-Y.

0:02:44.002,0:02:45.968
Vamos fazer!

0:02:45.968,0:02:51.395
Vamos dizer var positions[br]igual a um vetor.

0:02:51.395,0:02:55.852
Mas, cada elemento, ao invés de ser[br]um número, será um objeto.

0:02:55.852,0:03:04.691
Aqui abrimos chave e vamos apenas[br]dizer X:99, Y:117.

0:03:04.691,0:03:13.392
Ok, temos agora nossas posições aqui, [br]e vamos adicionar outra aqui.

0:03:13.392,0:03:32.877
Certo, X deve ser 294, 117, e o terceiro[br]será 101, 316, e o último é 294 e 316.

0:03:32.877,0:03:37.524
Ok! Agora, temos um vetor de objetos onde[br]cada objeto tem propriedades X e Y.

0:03:37.524,0:03:44.228
Aqui em baixo, no loop for, mudamos apenas[br]isso aqui para iterar por positions.length

0:03:44.228,0:03:48.993
Então passamos o objeto.

0:03:48.993,0:03:53.238
Agora estamos passando o objeto inteiro,[br]mas queremos passar o X e o Y,

0:03:53.238,0:03:59.548
então precisamos de [br]positions [ i ].X e positions [ i ].Y

0:03:59.548,0:04:00.808
Ta-da!

0:04:00.808,0:04:04.999
Agora podemos nos livrar destes[br]vetores antigos confusos.

0:04:04.999,0:04:10.034
Ótimo, parece-me bem melhor e[br]torna o código mais legível

0:04:10.034,0:04:12.959
e sempre que pudermos ter código[br]mais legível, melhor.

0:04:12.959,0:04:14.956
E também está mais fácil adicionar.

0:04:14.956,0:04:19.204
Se quisermos adicionar um, só precisamos[br]adicionar o par junto,

0:04:19.204,0:04:25.142
e aí podemos dizer X é 200, Y 200, nos dá um[br]pequeno Winston aqui no meio.

0:04:26.872,0:04:27.961
Beleza.

0:04:27.961,0:04:31.266
Agora quero mostrar algo[br]ainda mais sofisticado.

0:04:31.266,0:04:38.635
Percebe que nossa função aceita dois[br]números e depois os usa.

0:04:38.635,0:04:42.166
Bem, poderíamos mudar nossa função[br]para que espere um objeto

0:04:42.166,0:04:45.697
e depois pegue o X e Y do objeto,

0:04:45.697,0:04:49.230
o que significa que aqui embaixo só[br]teríamos que passar o objeto.

0:04:50.060,0:04:50.846
Vamos tentar!

0:04:50.846,0:04:53.596
Passamos o objeto, agora não funciona.

0:04:53.596,0:04:58.208
Isso porque nossa função ainda espera dois[br]objetos e está recebendo apenas um,

0:04:59.278,0:05:00.050
então vamos mudá-la

0:05:00.050,0:05:02.370
para dizer que recebe facePosition,[br]

0:05:04.220,0:05:06.710
e agora deu erro porque faceX[br]não está definido,

0:05:06.710,0:05:12.196
por que antes estávamos passando faceX[br]como argumento, mas agora ele não existe,

0:05:12.196,0:05:12.862
temos apenas um objeto.

0:05:12.862,0:05:21.159
O que podemos fazer, é salvar a posição X[br]de um objeto dentro da variável faceX.

0:05:21.159,0:05:24.945
Estamos dizendo que temos este objeto,[br]sabemos que ele tem uma propriedade X,

0:05:24.945,0:05:28.271
então vamos apenas guardá-la[br]na variável faceX.

0:05:28.871,0:05:33.637
Podemos fazer o mesmo com Y, [br]então faceY = facePosition.y;

0:05:33.637,0:05:34.850
Ta-da!

0:05:34.850,0:05:38.167
E então, o resto da função usa[br]faceX e faceY.

0:05:38.167,0:05:40.146
Agora, temos que ter certeza[br]que soletramos corretamente,

0:05:40.146,0:05:44.805
se escrevermos xx, não vai funcionar,[br]porque não é o que está aqui embaixo

0:05:44.805,0:05:48.125
no nosso vetor de objetos. Precisa bater.

0:05:48.125,0:05:52.136
Isso é bem legal, porque agora você pode[br]ter um vetor de objetos,

0:05:52.136,0:05:54.117
pode ter funções que recebem objetos

0:05:54.117,0:06:00.160
e você vai ver que seus programas ficarão [br]poderosos com essa estrutura de dados.

0:06:00.160,0:06:04.434
Especialmente porque é tão comum querer[br]junto um par X e Y.

0:06:04.434,0:06:08.926
Será especialmente útil nos seus programas[br]de desenho e animação aqui.

0:06:08.926,0:06:10.869
Então, vá fundo e se divirta!

0:06:10.869,0:06:15.589
[Legendado por: Fred Guth] [Revisado por: Alef Almeida]