En nuestra guía paso a paso anterior, aprendimos como hacer un tipo de objeto para representar nuestros dos objetos estilo "Winston",
y luego inicializarlos con los constructores.
Ahora, nuestro objeto no sólo puede estar asociado con propiedades,
también puede estar asociado con funcionalidades. Piensa en el mundo y todos los tipos de objetos que hay en él,
como los humanos. Todos tenemos estatura y edad, pero también tenemos cosas que podemos hacer, como dormir, comer y programar.
Y queremos poder asociar esas funciones con esos tipos de objetos.
En este programa, que está como lo dejamos la última vez, tenemos una función,
"drawWinston", que llamamos con los dos objetos "Winston". ¿No estaría bien que ligaramos esa función
al tipo de objeto "Winston"?, Bueno, podemos hacerlo y es fácil.
Así que debajo de nuestro constructor, vamos a escribir "Winston", con "W" mayúscula, punto "prototype".
"Prototype" (prototipo), es una palabra nueva que probablemente no habías visto antes.
Y "prototype" es la propiedad de un objeto a la que podemos ligar funciones,
y eso significa que cada objeto que sea una instancia de este objeto tendrá esas funciones.
Así que podemos escribir: punto "prototype" y luego punto, y el nombre de la función, en este caso "draw",
igual a... y podemos tomar el código de la función "drawWinston" y ponerlo aquí,
moverlo aquí dentro. Muy bien, lo que hicimos fue ligar la función "draw"
con nuestro prototipo "Winston". Y eso significa que podremos llamar la función "draw()" desde cualquier objeto tipo "Winston".
Muy bien, entonces podemos llamar la función "draw()" en "winstonTeen" o en "winstonAdult".
Y cuando tenemos una función como ésta, la podemos llamar en el objeto,
y en realidad a esto lo llamamos "método", así que ahora me oirás decir "método".
Entonces digamos que esto es "el método dibujar" ("the draw method"). Ok.
Así que ahora borramos esto, y vamos a ver si podemos llamar a "draw()".
"winstonTeen.draw()"
Ok. Tenemos un error, tenemos este error aquí afuera que dice: "winstObject is not defined".
Ok. Entonces, antes estábamos pasando este argumento a la función "drawWinston", que era el objeto "Winston",
pero ahora ya no lo estamos pasando. Podríamos cambiar esto y pasarlo,
y luego, déjenme ver, ¿qué deberíamos pasar aquí? Tenemos que pasar "winstonTeen". Ok.
Esto funciona, pero es muy tonto hacer esto. Estoy llamando la función "draw" sobre el mismo objeto.
No debería pasar el objeto. Esto es redundante.
Y es cierto, no debemos hacer eso, vamos a borrar esto y pensemos un poco.
Si estamos dentro del objeto, ¿qué podríamos usar para acceder a las propiedades del objeto?
Bueno, deberíamos fijarnos en nuestro constructor y recordar la palabra clave "this" y pensar: "Ah,
debemos cambiar esto por 'this'". Así que cambiamos "winstObject" por "this".
Porque ahora estamos dentro del objeto. Esta función está siendo evaluada
en el objeto, así que "this" se refiere al objeto actual.
Y de esta manera podemos usar simplemente "this" y estaremos teniendo acceso a todas las propiedades del objeto actual.
Y eso funciona totalmente, ¿Lo ven? ¿No es genial?
Entonces ahora podemos escribir "winstonAdult.draw()".
¡Tan tan! Y tendrá acceso a las propiedades de "winstonAdult" porque es el objeto en el que se llama.
Esto es lo bueno de esta palabra clave "this", aunque a veces puede ser un poco confuso usarla.
Muy bien, esto ha sido muy divertido, así que añadamos otro método. Ok. ¿Qué más podría hacer "Winston"?
Tal vez hablar. Así que haremos un "Winston.prototype.talk". Podemos ligar tantos métodos como queramos al prototipo.
Así que vamos a decir: "I´m Winston" ("Soy Winston").
Y luego lo escribimos en "this.x+20" y "this.y+150".
Entonces vemos que no pasa nada, pero es porque todavía no he llamado esa función.
Así que hagamos hablar al adolescente, "winstonTeen.talk()", ok,
"I´m Winston" ¡Tan tan! Y luego "winstonAdult.talk()".
¡Tan tan! Muy bien, ahora tenemos este tipo de objeto "Winston" que tiene propiedades: "nickname",
"age"," x", "y"; y tiene funcionalidad: comportamiento, métodos, que actúan de forma diferente dependiendo de las propiedades.
Y podemos crear tantas instancias de "Winston" como queramos, y llamar cualquiera de estos método en ellos.
Bastante bien ¿o no?