0:00:00.780,0:00:06.234
En nuestra guía paso a paso anterior, aprendimos como hacer un tipo de objeto para representar nuestros dos objetos estilo "Winston",

0:00:06.234,0:00:09.234
y luego inicializarlos con los constructores.

0:00:09.234,0:00:13.472
Ahora, nuestro objeto no sólo puede estar asociado con propiedades,

0:00:13.472,0:00:18.806
también puede estar asociado con funcionalidades. Piensa en el mundo y todos los tipos de objetos que hay en él,

0:00:18.806,0:00:26.287
como los humanos. Todos tenemos estatura y edad, pero también tenemos cosas que podemos hacer, como dormir, comer y programar.

0:00:26.287,0:00:30.939
Y queremos poder asociar esas funciones con esos tipos de objetos.

0:00:30.939,0:00:35.949
En este programa, que está como lo dejamos la última vez, tenemos una función,

0:00:35.949,0:00:43.066
"drawWinston", que llamamos con los dos objetos "Winston". ¿No estaría bien que ligaramos esa función

0:00:43.066,0:00:48.569
al tipo de objeto "Winston"?, Bueno, podemos hacerlo y es fácil.

0:00:48.569,0:00:55.725
Así que debajo de nuestro constructor, vamos a escribir "Winston", con "W" mayúscula, punto "prototype".

0:00:55.725,0:00:59.232
"Prototype" (prototipo), es una palabra nueva que probablemente no habías visto antes.

0:00:59.232,0:01:05.881
Y "prototype" es la propiedad de un objeto a la que podemos ligar funciones,

0:01:05.881,0:01:13.309
y eso significa que cada objeto que sea una instancia de este objeto tendrá esas funciones.

0:01:13.309,0:01:19.612
Así que podemos escribir: punto "prototype" y luego punto, y el nombre de la función, en este caso "draw",

0:01:19.612,0:01:25.606
igual a... y podemos tomar el código de la función "drawWinston" y ponerlo aquí,

0:01:25.606,0:01:32.951
moverlo aquí dentro. Muy bien, lo que hicimos fue ligar la función "draw"

0:01:32.951,0:01:40.008
con nuestro prototipo "Winston". Y eso significa que podremos llamar la función "draw()" desde cualquier objeto tipo "Winston".

0:01:40.008,0:01:45.411
Muy bien, entonces podemos llamar la función "draw()" en "winstonTeen" o en "winstonAdult".

0:01:45.411,0:01:49.569
Y cuando tenemos una función como ésta, la podemos llamar en el objeto,

0:01:49.569,0:01:54.833
y en realidad a esto lo llamamos "método", así que ahora me oirás decir "método".

0:01:54.833,0:01:58.272
Entonces digamos que esto es "el método dibujar" ("the draw method"). Ok.

0:01:58.272,0:02:04.103
Así que ahora borramos esto, y vamos a ver si podemos llamar a "draw()".

0:02:04.103,0:02:07.069
"winstonTeen.draw()"

0:02:07.069,0:02:13.697
Ok. Tenemos un error, tenemos este error aquí afuera que dice: "winstObject is not defined".

0:02:13.697,0:02:20.530
Ok. Entonces, antes estábamos pasando este argumento a la función "drawWinston", que era el objeto "Winston",

0:02:20.530,0:02:26.462
pero ahora ya no lo estamos pasando. Podríamos cambiar esto y pasarlo,

0:02:26.462,0:02:30.819
y luego, déjenme ver, ¿qué deberíamos pasar aquí? Tenemos que pasar "winstonTeen". Ok.

0:02:30.819,0:02:38.441
Esto funciona, pero es muy tonto hacer esto. Estoy llamando la función "draw" sobre el mismo objeto.

0:02:38.441,0:02:43.965
No debería pasar el objeto. Esto es redundante.

0:02:43.965,0:02:48.465
Y es cierto, no debemos hacer eso, vamos a borrar esto y pensemos un poco.

0:02:48.465,0:02:54.404
Si estamos dentro del objeto, ¿qué podríamos usar para acceder a las propiedades del objeto?

0:02:54.404,0:03:00.374
Bueno, deberíamos fijarnos en nuestro constructor y recordar la palabra clave "this" y pensar: "Ah,

0:03:00.374,0:03:08.573
debemos cambiar esto por 'this'". Así que cambiamos "winstObject" por "this".

0:03:08.573,0:03:12.951
Porque ahora estamos dentro del objeto. Esta función está siendo evaluada

0:03:12.951,0:03:16.861
en el objeto, así que "this" se refiere al objeto actual.

0:03:16.861,0:03:23.271
Y de esta manera podemos usar simplemente "this" y estaremos teniendo acceso a todas las propiedades del objeto actual.

0:03:23.271,0:03:26.720
Y eso funciona totalmente, ¿Lo ven? ¿No es genial?

0:03:26.720,0:03:31.907
Entonces ahora podemos escribir "winstonAdult.draw()".

0:03:31.907,0:03:38.271
¡Tan tan! Y tendrá acceso a las propiedades de "winstonAdult" porque es el objeto en el que se llama.

0:03:38.271,0:03:45.752
Esto es lo bueno de esta palabra clave "this", aunque a veces puede ser un poco confuso usarla.

0:03:45.752,0:03:52.028
Muy bien, esto ha sido muy divertido, así que añadamos otro método. Ok. ¿Qué más podría hacer "Winston"?

0:03:52.028,0:04:01.078
Tal vez hablar. Así que haremos un "Winston.prototype.talk". Podemos ligar tantos métodos como queramos al prototipo.

0:04:01.078,0:04:05.241
Así que vamos a decir: "I´m Winston" ("Soy Winston").

0:04:05.241,0:04:13.181
Y luego lo escribimos en "this.x+20" y "this.y+150".

0:04:13.181,0:04:19.734
Entonces vemos que no pasa nada, pero es porque todavía no he llamado esa función.

0:04:19.734,0:04:25.068
Así que hagamos hablar al adolescente, "winstonTeen.talk()", ok,

0:04:25.068,0:04:30.479
"I´m Winston" ¡Tan tan! Y luego "winstonAdult.talk()".

0:04:30.479,0:04:36.828
¡Tan tan! Muy bien, ahora tenemos este tipo de objeto "Winston" que tiene propiedades: "nickname",

0:04:36.828,0:04:45.026
"age"," x", "y"; y tiene funcionalidad: comportamiento, métodos, que actúan de forma diferente dependiendo de las propiedades.

0:04:45.026,0:04:51.123
Y podemos crear tantas instancias de "Winston" como queramos, y llamar cualquiera de estos método en ellos.

0:04:51.123,0:04:53.173
Bastante bien ¿o no?