0:00:00.414,0:00:03.370
No último vídeo, nós aprendemos[br]como fazer um tipo de objeto

0:00:03.370,0:00:05.865
para representar nossos dois[br]objetos do tipo Winston

0:00:05.865,0:00:09.115
e então os inicializamos [br]com os construtores.

0:00:09.841,0:00:13.240
Um tipo de objeto não deve apenas[br]ser associado com propriedades.

0:00:13.693,0:00:16.160
Também pode ser associado[br]com funcionalidades.

0:00:16.160,0:00:20.540
Pense no mundo e em todos os tipos [br]objetos que ele contem, como nós, humanos.

0:00:20.540,0:00:22.419
Todos nós possuímos alturas e idades,

0:00:22.419,0:00:24.630
mas também possuímos [br]coisas que podemos fazer,

0:00:24.630,0:00:26.837
como dormir, comer e programar.

0:00:26.837,0:00:30.545
E nós queremos poder associar [br]essas funções com os tipos de objeto.

0:00:30.901,0:00:34.654
Neste programa, que é o mesmo [br]que deixamos de lado na última vez,

0:00:34.654,0:00:36.185
nós temos uma função aqui,

0:00:36.185,0:00:39.371
drawWinston, que podemos chamar[br]nos dois objetos Winston.

0:00:40.400,0:00:44.974
Não ficaria melhor se pudéssemos [br]anexar isso ao tipo de objeto Winston?

0:00:45.651,0:00:48.492
Bem, nós podemos, e é fácil de se fazer.

0:00:48.787,0:00:50.938
Então, embaixo do nosso construtor,

0:00:50.938,0:00:55.371
escreveremos Winston, com W [br]maiúsculo, ponto prototype,

0:00:55.371,0:00:57.259
e o prototype, essa é uma palavra nova

0:00:57.259,0:00:59.847
a qual provavelmente você [br]ainda não tinha visto antes.

0:00:59.847,0:01:06.162
E o prototype é uma propriedade de [br]objeto que podemos anexar funções.

0:01:06.162,0:01:08.519
E isso irá significar que todo o objeto,

0:01:08.519,0:01:12.506
que seja um instância desse, [br]terá essas funções nele.

0:01:12.506,0:01:15.897
Então nós podemos dizer [br]ponto prototype e então ponto,

0:01:15.897,0:01:19.700
e depois o nome da função, [br]então escrevemos draw,

0:01:19.700,0:01:24.709
igual, e então pegamos nosso [br]código drawWinston

0:01:24.709,0:01:29.139
e podemos colocá-lo aqui [br]dentro. Tudo bem,

0:01:29.139,0:01:32.651
então o que fizemos foi[br]anexar uma função draw

0:01:32.651,0:01:35.001
ao nosso protótipo de Winston.

0:01:35.001,0:01:37.399
E isso significa que poderemos[br]chamar draw()

0:01:37.399,0:01:40.047
em qualquer objeto do tipo Winston.

0:01:40.047,0:01:45.415
Muito bem, então poderemos chamar[br]draw() em winstonTeen ou winstonAdult.

0:01:45.415,0:01:49.834
E quando temos um função desse tipo, [br]que podemos chamar um objeto,

0:01:49.834,0:01:54.420
nós chamamos de "método", então você [br]pode me escutar falar "método" agora.

0:01:54.420,0:01:58.234
Então vamos dizer que isso é [br]"um método de desenhar". Okay.

0:01:58.234,0:02:01.171
Então agora nós iremos [br]deletar isso, e isso,[br]

0:02:01.171,0:02:04.528
e agora veremos se[br]podemos chamar draw().

0:02:04.528,0:02:07.248
winstonTeen.draw()

0:02:07.248,0:02:10.137
Okay. Temos um erro, [br]nós tivemos esse erro aqui,

0:02:10.137,0:02:13.895
então ele diz: [br]"winstObject não está definido"

0:02:13.895,0:02:18.783
Okay. Então antes, nós estávamos passando [br]esse argumento dentro de drawnWinston,

0:02:18.783,0:02:21.527
o qual possui o objeto Winston,

0:02:21.527,0:02:23.525
mas agora não estamos [br]passando mais.

0:02:23.525,0:02:26.311
Hum, então, poderíamos mudar[br]isso para que passasse

0:02:26.311,0:02:30.792
e, vamos ver, o que passaremos aqui? [br]Temos que passar winstonTeen. Okay?

0:02:30.792,0:02:33.866
Isso funcionou, mas [br]também parece muito bobo.

0:02:33.866,0:02:38.430
Eu já estou chamando [br]draw no próprio objeto.

0:02:38.430,0:02:43.619
Eu não deveria ter que passar o objeto[br]também. Isso parece redundante.

0:02:43.619,0:02:46.106
E isso é verdade, não [br]deveríamos ter que fazer isso,

0:02:46.106,0:02:48.531
então vamos deletar isso [br]aqui e agora vamos pensar.

0:02:48.531,0:02:50.663
Se nós estamos dentro do objeto,

0:02:50.663,0:02:53.924
o que poderíamos usar para [br]acessar as propriedades do objeto.

0:02:53.924,0:02:56.451
Bem, você poderia dar uma [br]olhada no nosso construtor,

0:02:56.451,0:03:00.859
e lembre-se da palavra-chave [br]especial "this" (este) e pense " ahh "

0:03:00.859,0:03:08.733
"E se trocarmos this, por isto?" [risos] [br]Então trocamos winstObject por "this"

0:03:08.733,0:03:12.564
Porque agora nós já estamos dentro de [br]um objeto. Essa função está sendo avaliada

0:03:12.564,0:03:17.034
no objeto, então o "this" [br]irá se referir ao objeto atual.

0:03:17.034,0:03:19.568
Dessa maneira [br]podemos dizer "this"

0:03:19.568,0:03:23.554
e teremos acesso a todas as[br]propriedades deste objeto atual.

0:03:23.554,0:03:26.934
E isso realmente funciona, viu? [br]Não é legal?

0:03:26.934,0:03:31.922
Então agora podemos [br]dizer winstonAdult.draw()

0:03:31.922,0:03:35.760
Ta-da! E isso irá acessar as [br]propriedades do winstonAdult

0:03:35.760,0:03:38.530
porque é o objeto que [br]está sendo chamado.

0:03:38.530,0:03:41.869
Então isso é o que é realmente [br]legal sobre esse palavra-chave "this",

0:03:41.869,0:03:45.395
mesmo que seja confuso algumas vezes.

0:03:45.395,0:03:49.856
Muito bem, isso foi muito divertido, [br]então vamos adicionar outro método.

0:03:49.856,0:03:52.245
Okay, então, o que mais [br]o Winston pode fazer?

0:03:52.245,0:03:56.857
Talvez ele irá falar. Então nós [br]faremos um Winston.prototype.talk,

0:03:56.857,0:04:00.681
assim nós poderemos anexar quantos [br]métodos nós quisermos ao prototype.

0:04:00.681,0:04:05.666
Então nós iremos dizer "Eu sou Winston!"

0:04:05.666,0:04:12.475
E depois nós iremos dizer [br]this.x+20, e this.y+150.

0:04:12.475,0:04:19.948
E então, nada aconteceu, mas isso foi [br]porque ainda não chamei a função.

0:04:19.948,0:04:24.795
Então, vamos fazer o teen talk, [br]winstonTeen.talk(). Okay.

0:04:24.795,0:04:30.441
Eu sou Winston, ta-da! [br]E depois winstonAdult.talk()

0:04:30.441,0:04:32.726
Ta-da! Muito bem,

0:04:32.726,0:04:35.200
então agora temos esse[br]tipo de objeto Winston

0:04:35.200,0:04:38.544
que possui propriedades: [br]apelido, idade, x, y;

0:04:38.544,0:04:41.760
e possui funcionalidades: [br]comportamentos, métodos;

0:04:41.760,0:04:44.946
que se comportam diferente [br]dependendo das propriedades

0:04:44.946,0:04:48.797
e podemos criar quantas instâncias[br]de Winstons nós quisermos

0:04:48.797,0:04:50.705
e chama qualquer desses métodos nele.

0:04:50.705,0:04:52.302
Bem legal, né?

0:04:52.302,0:04:53.512
Legendado por [Gabriel Mello Fernandes]