JavaScript
¿Qué es JavaScript?
JavaScript es un lenguaje de programación interpretado, dinámico, de alto nivel y enfocado en la web. Junto con HTML y CSS, conforma el núcleo del desarrollo frontend moderno, permitiendo crear interfaces interactivas, aplicaciones web complejas y desarrollo en el servidor mediante Node.js.
Componentes del ecosistema
- Motor V8 / JavaScript Engine: motor encargado de interpretar y compilar código JS en tiempo real (JIT).
- NPM (Node Package Manager): el registro de paquetes y librerías más grande para el ecosistema de JS.
- Node.js: entorno de ejecución que permite ejecutar JavaScript fuera del navegador, del lado del servidor.
Tipos de datos principales
- Números:
number(ej.10,3.14). - Texto:
string(utiliza' '," "o backticks` `). - Booleanos:
boolean(valorestrueofalse). - Especiales:
null(ausencia intencional) yundefined(valor no asignado). - Objetos y Arreglos:
object/array.
Variables
En JavaScript moderno utilizamos let para variables cuyos valores cambian y const para valores constantes o referencias inmutables. Con typeof podemos preguntar de qué tipo es un valor.
Declaración con let y const
let edad = 26;
const PI = 3.1416;
const saludo = `Hola, mi edad es ${edad}`; // Template literals
console.log(saludo);
console.log(typeof edad, typeof saludo);
Podés reasignar valores y usar asignación compuesta directamente, pero si intentamos cambiar una constante el navegador nos muestra un error:
Acumular en una variable y reasignar una constante
let total = 0;
total += 5; // equivale a total = total + 5
PI = 3; // no se puede, PI es const
Tip: evitá usar var. Preferí siempre const por defecto y let cuando el valor de la variable necesite cambiar.
Operadores
JavaScript incluye operadores aritméticos, lógicos y de comparación. Es recomendable usar igualdad estricta (===) para verificar valor y tipo de dato sin conversiones implícitas.
Operadores aritméticos, de comparación y lógicos
let suma = 5 + 3; // Aritméticos: + - * / % **
const esIgual = (edad === 18); // Igualdad estricta: === !== > < >= <=
const puede = mayor && activo; // Lógicos: && (y) || (o) ! (no)
Probando en la consola del navegador (F12)
Tip: con un texto, el + une en vez de sumar. Por eso "5" + 3 da '53', mientras que "5" - 3 convierte el texto a número y da 2.
Condicionales
Estructuras para evaluar expresiones booleanas mediante if, else if, else, operador ternario y la sentencia switch.
Estructura if / else if / else
const edad = 15;
if (edad >= 18) {
console.log("Mayor de edad");
} else if (edad >= 13) {
console.log("Adolescente");
} else {
console.log("Niño");
}
Switch y Operador Ternario
// Operador ternario
const estado = edad >= 18 ? "Adulto" : "Menor";
console.log(estado);
// Switch
const dia = 2;
switch (dia) {
case 1:
console.log("Lunes");
break;
case 2:
console.log("Martes");
break;
default:
console.log("Otro día");
}
Bucles e iteraciones
Nos permiten repetir código eficientemente con for, while, así como iteradores modernos de colecciones como for...of y for...in.
for, while y for...of
const nombres = ["Ana", "Leo"];
for (let i = 0; i < 3; i++) {
console.log(i);
}
let contador = 0;
while (contador < 10) {
contador++;
}
for (const nombre of nombres) {
console.log(nombre);
}
Tip: break interrumpe el bucle por completo y continue pasa directamente a la siguiente iteración.
Funciones
Las funciones son bloques de código reutilizables. JavaScript soporta funciones tradicionales y funciones flecha (arrow functions) con sintaxis concisa.
Declaración y Arrow Functions
// Función tradicional
function sumar(a, b) {
return a + b;
}
// Arrow function
const saludar = (nombre = "Visitante") => `Hola ${nombre}`;
console.log(sumar(4, 6));
console.log(saludar("Ana"));
console.log(saludar());
Arreglos y Objetos
Las estructuras complejas en JS son objetos y listas (arrays) con métodos integrados para manipulación de datos:
Arreglos (Array)
Colecciones ordenadas de elementos con métodos como push, map y filter.
Objetos Literales
Estructuras clave-valor para representar entidades con propiedades y métodos.
push, map y filter
const notas = [7, 4, 9];
notas.push(10);
const dobles = notas.map(n => n * 2);
const aprobadas = notas.filter(n => n >= 6);
console.log(dobles);
console.log(aprobadas);
Objetos
const usuario = {
nombre: "Ana",
edad: 17,
saludar() { return "Hola"; }
};
console.log(usuario.nombre);
console.log(usuario);
Manipulación del DOM
El DOM (Document Object Model) representa la estructura HTML como un árbol de objetos manipulable desde JS para responder a eventos del usuario. En este ejemplo la página tiene un <h2 class="titulo"> y un <button id="miBoton">.
Selección de elementos y eventos
const boton = document.querySelector("#miBoton");
const titulo = document.querySelector(".titulo");
boton.addEventListener("click", () => {
titulo.textContent = "¡Texto cambiado!";
});
Tip: el título decía "Texto original" y cambió después del click, sin recargar la página.
Asincronía (Promises y Async/Await)
Permite ejecutar tareas no bloqueantes, como peticiones HTTP a servidores (APIs) utilizando promesas y la sintaxis async/await. Mientras esperamos la respuesta, el resto del código sigue ejecutándose.
Consumo de APIs con Fetch y Async/Await
async function obtenerDatos() {
try {
const respuesta = await fetch("https://api.ejemplo.com/usuarios/1");
const datos = await respuesta.json();
console.log(datos);
} catch (error) {
console.error("Error al obtener datos:", error);
}
}
obtenerDatos();
console.log("Esto se muestra primero");
Tip: si no hay conexión, se ejecuta el catch y la consola muestra en rojo: Error al obtener datos: TypeError: Failed to fetch.