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
Viendo ahora - 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
Funciones puras e impuras
Resumen
Saber distinguir entre una función pura y una función impura es fundamental para escribir código más predecible y fácil de mantener. A continuación se desglosan sus características, los side effects más comunes y varios ejemplos prácticos que aclaran cuándo una función deja de ser pura.
¿Qué hace que una función sea pura?
Una función pura cumple dos reglas sencillas [0:37]:
- Misma entrada, misma salida. Sin importar cuántas veces la ejecutes, si le pasas los mismos argumentos siempre devolverá el mismo resultado.
- Sin efectos secundarios. No modifica nada fuera de su propio ámbito ni depende de valores externos que puedan cambiar.
Estas dos propiedades convierten a la función en una pieza confiable: puedes probarla, reutilizarla y componerla con otras funciones sin sorpresas.
¿Qué son los side effects y cuáles existen?
Los efectos secundarios —o side effects— son cualquier acción que rompa alguna de las dos reglas anteriores [1:25]. Los más habituales son:
- Modificar variables globales. Acceder y cambiar una variable que vive fuera de la función.
- Modificar parámetros. Alterar el valor de los argumentos recibidos.
- Solicitudes HTTP. Llamadas a APIs externas cuyo resultado puede variar.
- Imprimir mensajes en pantalla o consola. Usar
console.logoalert. - Manipulación del DOM. Consultar o cambiar elementos de la interfaz.
- Obtener la hora actual. Funciones como
Date.now()devuelven un valor distinto cada vez.
Es importante entender que los side effects no son necesariamente malos [3:22]. Hacer debugging con console.log, consumir una API o actualizar el DOM son tareas cotidianas e imprescindibles. Simplemente hacen que la función involucrada deje de clasificarse como pura.
¿Cómo se ve una función pura en código?
El ejemplo más directo es una función de suma [3:50]:
js function sum(a, b) { return a + b; }
Siempre que reciba los mismos valores de a y b, devolverá el mismo resultado. No toca variables externas ni ejecuta ningún side effect.
¿Un console.log convierte una función pura en impura?
Sí. Si a la misma función le agregamos una línea como console.log(a), ya estamos imprimiendo un mensaje en consola, lo cual constituye un efecto secundario [4:28]. La función pasa automáticamente a ser impura.
js function sum(a, b) { console.log(a); // side effect return a + b; }
Otro caso clásico es modificar una variable global [5:17]:
js let total = 0;
function sumWithSideEffect(a) { total += a; return total; }
Cada vez que se invoque, total cambia, por lo que la salida será diferente aunque el parámetro sea el mismo. Eso la hace impura de forma evidente.
¿La combinación de funciones puras sigue siendo pura?
Considera estas dos funciones [7:05]:
js function square(x) { return x * x; }
function addTen(y) { return y + 10; }
Ambas son puras: misma entrada, misma salida, cero side effects. Ahora combínalas [7:42]:
js const number = 5; const finalResult = addTen(square(number)); console.log(finalResult); // 35
El resultado es 35 porque square(5) devuelve 25 y addTen(25) devuelve 35. La composición de dos funciones puras sigue siendo pura [8:30]. No se introduce ningún efecto secundario nuevo en la lógica de cálculo; el console.log solo se usa para verificar el resultado, fuera de las funciones en sí.
La regla práctica es directa: revisa si tu función cumple con las dos características iniciales y comprueba que no incurra en ninguno de los side effects listados. Si pasa ambas pruebas, es pura. De lo contrario, es impura, y eso está bien siempre que seas consciente de ello.
¿Tienes algún caso en tu código donde no estés seguro si tu función es pura o impura? Compártelo en los comentarios.