0:00:01.342,0:00:05.959
Ahora que entiendes los fundamentos de Javascript, quiero enseñarte una forma genial de usar Javascript.

0:00:05.959,0:00:09.546
Algo que llamamos "Programación orientada a objetos"

0:00:09.546,0:00:12.570
Pero primero debemos entender por qué es realmente útil.

0:00:12.570,0:00:17.668
Así que puse aquí un programa que estará mejorado una vez que lo hagamos más orientado a objeto.

0:00:17.668,0:00:25.138
Ahora, éste es un buen programa para empezar. En la parte superior, tenemos dos variables que almacenan literales de objeto.

0:00:25.138,0:00:30.448
Ahora, los literales de objeto son un tipo de objetos que aprendimos antes y que creamos con dos llaves ({}),

0:00:30.448,0:00:34.409
y dentro de las cuales ponemos la información de los nombres y valores de las propiedades.

0:00:34.409,0:00:39.241
Así que aquí tenemos dos de esas variables literales de objeto, y aquí abajo tenemos esta función "drawWinston",

0:00:39.241,0:00:41.129
que espera recibir un argumento simple,

0:00:41.129,0:00:47.882
y después dibuja el argumento, dibuja una imagen basada en la "x" y "y" que son propiedades del objeto,

0:00:47.882,0:00:53.107
y luego un título basado en el sobrenombre y la edad que son propiedades del objeto.

0:00:53.107,0:00:58.164
Y finalmente hasta abajo, llamamos la fución "drawWinston()" para el adolescente y para el adulto,

0:00:58.164,0:01:01.012
que es lo que hace que se muestren.

0:01:01.012,0:01:06.366
Muy bien. Ahora si vamos de este lado y vemos estas literales de objeto,

0:01:06.366,0:01:11.410
fíjense que se ven muy similares.

0:01:11.410,0:01:17.842
Las dos tienen el mismo conjunto de propiedades, y las dos pueden ser usadas por la misma función "drawWinston()".

0:01:17.842,0:01:24.072
De hecho, si piensas en esto, las dos están describiendo un tipo de "Winston", ¿cierto?

0:01:24.072,0:01:28.796
Y podríamos pensar que existe algo así como un tipo abstracto de "Winston" en el mundo,

0:01:28.796,0:01:36.460
y que cada "Winston" tiene el mismo conjunto de propiedades como un sobrenombre ("nickname"), edad ("age"), una "x" y una "y",

0:01:36.460,0:01:42.162
y aquí, hemos creado dos instancias de "Winston"

0:01:42.162,0:01:48.465
para describir un "Winston" particular. Este es un "Winston" adolescente, y este es un "Winston" adulto.

0:01:48.465,0:01:54.762
Pero los dos en realidad son muy similares, y hay muchas cosas que son similares entre ellos.

0:01:54.762,0:02:01.295
Y si lo piensas bien, así es como funciona el mundo, tenemos tipos de datos abstractos como seres humanos y gente,

0:02:01.295,0:02:05.958
y cada uno de nosotros somos instancias específicas de ellos con nuestras propias pequeñas propiedades.

0:02:05.958,0:02:14.948
Ahora, podemos usar técnicas orientadas a objetos en Javascript de tal forma que estas variables de "Winston"

0:02:14.948,0:02:21.834
sean instancias formales del objeto "Winston", de manera que ellos sepan que están compartiendo cosas en común.

0:02:21.834,0:02:27.974
Entonces, para hacer eso, en primer lugar tenemos que describir este tipo de dato abstracto llamado "Winston".

0:02:27.974,0:02:30.900
Y lo haremos con una variable.

0:02:30.900,0:02:38.934
Almacenaremos el tipo de dato en una variable. Así que "var Winston" y usaremos "W" mayúscula porque debemos iniciar nuestros objetos con mayúscula,

0:02:38.934,0:02:42.196
y lo igualaremos a una función.

0:02:42.196,0:02:47.030
Y esta función es una función especial que llamamos "función constructora",

0:02:47.030,0:02:52.042
porque vamos a llamar esta función cada vez que queramos crear una nueva instancia de "Winston".

0:02:52.042,0:02:57.860
Así que si queremos crear un "Winston" adolescente llamaremos esta función y si queremos crear un "Winston" adulto llamaremos esta función.

0:02:57.860,0:03:06.417
Esto significa que esta función debe tomar cualquier argumento que necesite saber para crear un "Winston" completo.

0:03:06.417,0:03:11.324
En este caso necesita conocer el sobrenombre ("nickname"), la edad ("age"), la "x" y la "y".

0:03:11.324,0:03:15.063
Ahora, una vez que tenemos esos argumentos, vamos a hacer algo con ellos,

0:03:15.063,0:03:21.483
tenemos que adjuntar esa información al objeto "Winston".

0:03:21.483,0:03:28.672
Para eso usaremos una nueva y especial palabra clave: "this". Y "this" se referirá a la instancia actual del objeto.

0:03:28.672,0:03:34.921
Así que escribimos "this.nickname", y esto significa que la propiedad "nickname" de este objeto es igual a

0:03:34.921,0:03:38.419
lo que sea que le pasemos a la función constructora, ¿ok?

0:03:38.419,0:03:45.728
Y "this.age" es igual a lo que le pasemos en "age", "this.x" es igual a la "x" que le pasemos, y "this.y"

0:03:45.728,0:03:48.385
es igual a la "y" que le pasemos.

0:03:48.385,0:03:57.500
Muy bien, ahora tenemos este tipo de dato abstracto llamado "Winston", y tiene una función constructora que podemos usar para crear un nuevo "Winston".

0:03:57.500,0:04:00.327


0:04:00.327,0:04:05.245


0:04:05.245,0:04:10.376


0:04:10.376,0:04:13.950


0:04:13.950,0:04:22.305


0:04:22.305,0:04:27.502


0:04:27.502,0:04:31.082


0:04:31.082,0:04:35.722


0:04:35.722,0:04:39.960


0:04:39.960,0:04:47.410


0:04:47.410,0:04:50.812


0:04:50.812,0:04:58.094


0:04:58.094,0:05:05.272


0:05:05.272,0:05:08.799


0:05:08.799,0:05:14.379


0:05:14.379,0:05:20.212


0:05:20.212,0:05:23.103


0:05:23.103,0:05:28.162


0:05:28.162,0:05:30.894


0:05:30.894,0:05:34.029


0:05:34.029,0:05:39.363


0:05:39.363,0:05:41.444


0:05:41.444,0:05:46.361


0:05:46.361,0:05:50.589


0:05:50.589,0:05:55.996


0:05:55.996,0:06:00.830


0:06:00.830,0:06:06.590


0:06:06.590,0:06:12.804


0:06:12.804,0:06:17.281


0:06:17.281,0:06:20.968


0:06:20.968,0:06:26.632


0:06:26.632,0:06:29.925


0:06:29.925,0:06:35.528


0:06:35.528,0:06:40.741


0:06:40.741,0:06:45.829


0:06:45.829,0:06:48.690


0:06:48.690,0:06:51.000