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
Viendo ahora - 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
02:15 min - 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
Paso por valor
Resumen
¿Qué es el paso por valor y el paso por referencia en JavaScript?
JavaScript es un lenguaje versátil y profundo que requiere comprender conceptos únicos como el paso por valor y el paso por referencia. Estos conceptos son centrales para manejar correctamente los tipos de datos y su comportamiento en memoria. Basándonos en una clase práctica, exploraremos estas nociones aplicadas a variables primitivas y complejas.
¿Cómo se visualizan los tipos de datos primitivos en memoria?
Los tipos de datos primitivos en JavaScript son inmutables y se pasan por valor, lo que significa que, al asignar una variable a otra, se copia el valor sin afectar al original. Ejemplo:
let x = 1; let y = 'hola'; let z = null; let a = x; let b = y; let c = z; console.log(x, y, z, a, b, c); // Salida: 1, "hola", null, 1, "hola", null
En memoria, al cambiar los valores de x, y o z, a, b y c no se ven afectados, pues los datos primitivos hacen una copia exacta. Esto exalta el papel fundamental de cómo los datos primitivos se comportan en nuestras aplicaciones.
¿Qué ocurre con los tipos de datos complejos y el paso por referencia?
Los tipos de datos complejos, como los objetos y arrays, son mutables y se pasan por referencia. En lugar de copiar el valor, se copia una referencia que apunta a una ubicación de memoria. Aquí un ejemplo práctico con arrays:
let frutas = ['manzana']; frutas.push('pera'); console.log(frutas); // Salida: ["manzana", "pera"]
En este caso, al modificar el array frutas, lo que se actualiza es la referencia en memoria. Esto implica que, cualquier cambio hecho sobre esa referencia, se reflejará en el objeto original, mostrando claramente el comportamiento mutable de las estructuras de datos complejas.
¿Qué ocurre al asignar variables que contienen arrays?
Analizar cómo múltiples variables pueden apuntar al mismo objeto en memoria puede revelar la naturaleza del paso por referencia. Considera el siguiente código:
let panes = ['🥖']; let copiaDePanes = panes; panes.push('🍞'); console.log(panes, copiaDePanes); // Salida: ['🥖', '🍞'], ['🥖', '🍞']
Ambas, panes y copiaDePanes, apuntan a la misma dirección de memoria. Cualquier modificación en el array afectará a ambas variables, manifestando así un comportamiento compartido que ilustra el concepto de referencias de memoria comunes.
¿Cuál es la diferencia clave entre los pasos por valor y por referencia?
En resumen, la diferencia reside en cómo se manejan las copias:
-
Paso por valor: se copia el valor literal.
-
Paso por referencia: se copia una dirección de memoria.
Este conocimiento es crucial para evitar errores comunes al manejar datos y diseñar soluciones eficientes en JavaScript. Aprender y dominar estas prácticas fomenta un uso efectivo de la memoria y un mayor control sobre cómo interactúan los datos en nuestras aplicaciones.