Contenido del curso
Primeros Pasos
- 5

¡Hola Mundo!
06:13 min - 6

Anatomía de una variable
09:23 min - 7

Tipos de datos: Mutabilidad e inmutabilidad
10:55 min - 8

Paso por valor
11:06 min - 9

Paso por referencia
07:00 min - 10

Creación de strings
11:33 min - 11

Concatenación de strings
08:31 min - 12

Manipulación de strings
12:13 min - 13

Tipo de dato primitivo: number
09:30 min - 14

Conversión a Booleanos
05:08 min - 15

Tipos de datos primitivos: null, undefined, symbol y bigint
07:28 min - 16

Conversión de tipos: Type Casting y Coercion
04:38 min - 17

Conversión de tipos explícita e implícita
12:20 min - 18

Proyecto: Crea un perfil para redes sociales con JavaScript
07:23 min
Funciones y This
- 19

Anatomía de una función
11:39 min - 20

Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?
02:11 min - 21

Funciones vs Métodos
10:01 min - 22

Funciones puras e impuras
11:22 min - 23

Identificador this
11:38 min - 24

Métodos bind, call y apply
10:09 min - 25

Funciones flecha y enlace léxico
10:31 min - 26

Implicaciones de duplicar código
03:19 min - 27

Funciones constructoras
10:41 min - 28

10 Tipos de funciones
01:39 min - 29

Objeto window y modo estricto
07:37 min - 30

Tipos de binding
01:11 min - 31

Expresiones vs Sentencias
04:02 min - 32

Proyecto: Crea biografías de personajes con JavaScript
12:51 min
Lógica y ciclos
- 33

Operadores de comparación
06:12 min - 34

Operadores lógicos
04:33 min - 35

Ejecución condicional: if
07:45 min - 36

Proyecto: Adivina el número
09:36 min - 37

Ejecución condicional: ternario
05:24 min - 38

Ejecución condicional: switch
12:08 min - 39

Loop: for
07:31 min - 40

Loop: forEach
03:57 min - 41

Loop: for of
04:26 min - 42

Loop: for in
07:38 min - 43

Loop: while
03:56 min - 44

Loop: do while
03:13 min - 45

Proyecto: Juego adivina la palabra
15:56 min
Fundamentos de arrays y modificación
- 46

Introducción a Arrays
09:09 min - 47

Mutabilidad e inmutabiliad de Arrays
07:56 min - 48

Modificación básica del final con push(), pop()
04:33 min - 49

Ejercicio: Stack de libros
16:03 min - 50

Modificación del principio con shift(), unshift()
10:21 min - 51

Modificación avanzada con splice(), reverse(), sort(), fill()
16:37 min - 52

Proyecto: Juego de cartas
15:37 min - 53

Preguntas a Desarrolladores Senior: Estrategias y métodos de estudio
01:10 min
Iteración de Arrays
- 54

Iteración con map() y forEach()
12:53 min - 55

Filtrado y reducción con filter() y reduce()
11:34 min - 56

Ejercicio: Calificación promedio aprobatoria
05:27 min - 57

Búsqueda de elementos con find() y findIndex()
03:52 min - 58

Ejercicio: Encuentra al ganador de una rifa
11:21 min - 59

Proyecto: Análisis de transacciones
10:55 min - 60

Proyecto: Análisis de transacciones parte 2
08:01 min
Métodos específicos y Operaciones
- 61

Unir y entrelazar con concat(), spread operator y join()
12:05 min - 62

Verificación y evaluación con every() y some()
05:15 min - 63

Métodos de búsqueda con includes(), indexOf() y lastIndexOf()
07:05 min - 64

Ejercicio: Encontrando los índices
11:09 min - 65

Crear copias con slice()
05:28 min - 66

Spread operator: casos de uso
07:11 min
Arrays multidimencionales
Clases y Objetos
- 71

Anatomia de un Objeto
06:48 min - 72

Trabajando con objetos
12:52 min - 73

Función constructora
14:31 min - 74

¿Qué es una clase?
06:17 min - 75

Prototipos y herencias
Viendo ahora - 76

Herencia en la práctica
15:38 min - 77

Prototipos en la práctica
10:42 min - 78

this en JavaScript
05:36 min - 79

Proyecto: Crea una red social
12:25 min - 80

Proyecto: Crea una red social parte 2
09:00 min
Prototipos y herencias
Resumen
Entender la relación entre prototipos y herencia es fundamental para trabajar con JavaScript y programación orientada a objetos. Estos dos conceptos determinan cómo se comparten propiedades y métodos entre objetos, y dominarlos marca la diferencia entre escribir código repetitivo y escribir código eficiente.
¿Qué diferencia hay entre objetos con prototipos y herencia?
JavaScript funciona con objetos y prototipos, mientras que la programación orientada a objetos tradicional se basa en herencia [0:12]. Aunque ambos mecanismos permiten reutilizar código, operan de manera distinta bajo la superficie.
Una clase constructora (o función constructora) actúa como un molde [0:28]. Dentro de ese molde se definen propiedades y métodos que después se utilizan para rellenar con información cada vez que se crea una nueva instancia.
¿Qué es un prototipo en JavaScript?
Cada vez que se trabaja con clases o funciones constructoras, JavaScript genera automáticamente un prototipo [0:48]. Este prototipo contiene todas las propiedades y métodos que se van a compartir o heredar en las instancias creadas a partir de la clase principal.
- El prototipo es un objeto interno que JavaScript asocia a cada constructor.
- Las instancias acceden a los métodos del prototipo sin necesidad de duplicarlos.
- Esto optimiza el uso de memoria, porque el método existe una sola vez en el prototipo.
¿Cómo se crea una instancia a partir de una clase?
Supongamos que tenemos una clase llamada Persona con ciertas propiedades y métodos. Al crear una instancia, le damos datos concretos [1:08]:
- Nombre: José.
- Edad: treinta años.
- Altura: uno setenta.
- Nacionalidad: colombiano.
Esa instancia, José, no necesita que le generemos manualmente cada método. Si la clase padre ya tiene definido un método llamado saludar, José lo hereda directamente gracias al prototipo [1:22].
¿Cómo funciona la herencia de métodos en la práctica?
El método saludar existe en la clase padre, no en la instancia de José. Cuando José ejecuta la acción de saludar, el resultado sería algo como: «Hola, mi nombre es José, ¿cómo te llamas tú?» [1:42].
Esto sucede porque JavaScript busca el método primero en la propia instancia y, si no lo encuentra, sube por la cadena de prototipos hasta dar con él en la clase constructora original.
- No es necesario reescribir métodos en cada instancia.
- El prototipo generado por la clase constructora permite que todas las instancias compartan los mismos métodos.
- Esto representa el concepto de herencia: la instancia recibe comportamientos definidos en la clase padre sin código adicional [1:56].
¿Por qué es importante distinguir clase padre e instancia?
La clase padre funciona como el molde general con propiedades y métodos reutilizables. La instancia es la versión concreta con datos específicos. Gracias a este modelo:
- Se evita la duplicación de lógica.
- Se mantiene un punto único de cambio: modificar el método en la clase padre actualiza el comportamiento de todas las instancias.
- Se aprovecha el sistema de prototipos que JavaScript implementa de forma nativa.
En resumen práctico, cuando defines un método como saludar en tu clase constructora, cada instancia que crees —sea José, María o cualquier otra persona— podrá ejecutar ese método sin que tengas que escribirlo nuevamente. El prototipo se encarga de que la herencia funcione de forma transparente.
Si ya estás creando tus primeras clases en JavaScript, prueba a definir métodos en la clase padre y observa cómo las instancias los heredan automáticamente. Comparte tu experiencia o dudas en los comentarios.