Analizar datos mediante funciones consiste en transformar listas de registros en respuestas útiles. Una función puede calcular un indicador, comparar períodos, segmentar usuarios, detectar cambios o resumir miles de valores en una conclusión.
El objetivo no es solo calcular números, sino construir un proceso repetible: recibir datos, aplicar reglas claras y obtener resultados interpretables.
Un análisis puede dividirse en pasos: cargar datos, limpiar, filtrar, transformar, resumir e interpretar.
function analizarVentas(ventas) {
const total = ventas.reduce((suma, venta) => suma + venta.monto, 0);
const cantidad = ventas.length;
return {
total,
cantidad,
promedio: total / cantidad
};
}
const ventas = [
{ monto: 100 },
{ monto: 250 },
{ monto: 150 }
];
console.log(analizarVentas(ventas));Un indicador resume una propiedad importante de los datos. Puede ser total, promedio, tasa, proporción, diferencia o crecimiento.
function tasaConversion(visitas, compras) {
if (visitas === 0) {
return 0;
}
return compras / visitas * 100;
}
console.log(tasaConversion(1200, 84).toFixed(2) + "%");Muchas preguntas se responden analizando solo una parte de los datos: un período, una categoría, una región o un tipo de usuario.
function ventasDeCategoria(ventas, categoria) {
return ventas.filter(venta => venta.categoria === categoria);
}
const ventas = [
{ categoria: "libros", monto: 120 },
{ categoria: "cursos", monto: 300 },
{ categoria: "libros", monto: 80 }
];
console.log(ventasDeCategoria(ventas, "libros"));Totalizar es una de las operaciones más frecuentes. Una función de total puede recibir una lista y el campo que debe sumarse.
function totalizar(registros, campo) {
return registros.reduce((total, registro) => total + registro[campo], 0);
}
const gastos = [
{ concepto: "servidor", costo: 120 },
{ concepto: "dominio", costo: 15 },
{ concepto: "soporte", costo: 80 }
];
console.log(totalizar(gastos, "costo"));Calcular promedios por grupo permite comparar segmentos. Por ejemplo, ventas promedio por canal o calificaciones promedio por curso.
function promedioPorGrupo(registros, grupo, campo) {
const acumulados = {};
for (const registro of registros) {
const clave = registro[grupo];
acumulados[clave] = acumulados[clave] || { suma: 0, cantidad: 0 };
acumulados[clave].suma += registro[campo];
acumulados[clave].cantidad++;
}
return Object.fromEntries(
Object.entries(acumulados).map(([clave, datos]) => [clave, datos.suma / datos.cantidad])
);
}
const notas = [
{ curso: "JS", nota: 8 },
{ curso: "JS", nota: 10 },
{ curso: "Python", nota: 7 }
];
console.log(promedioPorGrupo(notas, "curso", "nota"));Una función de comparación permite medir diferencia absoluta y variación porcentual entre dos períodos.
function comparar(actual, anterior) {
const diferencia = actual - anterior;
const variacion = anterior === 0 ? 0 : diferencia / anterior * 100;
return { diferencia, variacion };
}
console.log(comparar(1300, 1000));El crecimiento acumulado muestra cómo evoluciona un valor cuando se suman aportes sucesivos.
function acumulado(valores) {
let suma = 0;
return valores.map(valor => {
suma += valor;
return suma;
});
}
console.log(acumulado([10, 15, -5, 20]));Una forma sencilla de estimar tendencia es comparar el primer y el último valor de una serie.
function tendencia(valores) {
const primero = valores[0];
const ultimo = valores[valores.length - 1];
if (ultimo > primero) return "creciente";
if (ultimo < primero) return "decreciente";
return "estable";
}
console.log(tendencia([12, 15, 18, 22]));
console.log(tendencia([30, 28, 20]));El promedio móvil suaviza una serie de datos calculando promedios en ventanas consecutivas.
function promedioMovil(valores, ventana) {
const resultado = [];
for (let i = 0; i <= valores.length - ventana; i++) {
const tramo = valores.slice(i, i + ventana);
const promedio = tramo.reduce((suma, valor) => suma + valor, 0) / ventana;
resultado.push(promedio);
}
return resultado;
}
console.log(promedioMovil([10, 20, 30, 40, 50], 3));Un pico es un valor mayor que sus vecinos. Detectarlos ayuda a encontrar eventos especiales o anomalías.
function detectarPicos(valores) {
const picos = [];
for (let i = 1; i < valores.length - 1; i++) {
if (valores[i] > valores[i - 1] && valores[i] > valores[i + 1]) {
picos.push({ indice: i, valor: valores[i] });
}
}
return picos;
}
console.log(detectarPicos([10, 18, 12, 20, 15, 16]));Segmentar consiste en clasificar registros según reglas. Esto permite analizar comportamientos por grupos.
function segmentoCliente(compras) {
if (compras >= 10) return "frecuente";
if (compras >= 3) return "ocasional";
return "nuevo";
}
const clientes = [1, 4, 12].map(compras => ({
compras,
segmento: segmentoCliente(compras)
}));
console.log(clientes);Después de segmentar, se pueden contar registros por grupo para conocer la distribución.
function contarPorCampo(registros, campo) {
return registros.reduce((conteo, registro) => {
const clave = registro[campo];
conteo[clave] = (conteo[clave] || 0) + 1;
return conteo;
}, {});
}
const clientes = [
{ segmento: "nuevo" },
{ segmento: "frecuente" },
{ segmento: "nuevo" }
];
console.log(contarPorCampo(clientes, "segmento"));Un ranking ordena elementos según una métrica. Es útil para encontrar mejores productos, usuarios más activos o mayores costos.
function topN(registros, campo, n) {
return [...registros]
.sort((a, b) => b[campo] - a[campo])
.slice(0, n);
}
const productos = [
{ nombre: "A", ventas: 40 },
{ nombre: "B", ventas: 90 },
{ nombre: "C", ventas: 70 }
];
console.log(topN(productos, "ventas", 2));La participación muestra cuánto representa cada parte dentro de un total.
function participaciones(registros, campo) {
const total = registros.reduce((suma, registro) => suma + registro[campo], 0);
return registros.map(registro => ({
...registro,
participacion: registro[campo] / total * 100
}));
}
const canales = [
{ nombre: "orgánico", visitas: 500 },
{ nombre: "ads", visitas: 300 },
{ nombre: "referidos", visitas: 200 }
];
console.log(participaciones(canales, "visitas"));Un índice base 100 permite comparar evolución relativa. El primer valor se toma como 100 y los demás se expresan en relación a ese valor.
function indiceBase100(valores) {
const base = valores[0];
return valores.map(valor => valor / base * 100);
}
console.log(indiceBase100([200, 240, 180, 300]));Antes de interpretar resultados, hay que revisar si faltan campos necesarios.
function tieneCampos(registro, campos) {
return campos.every(campo => registro[campo] !== undefined && registro[campo] !== null);
}
const registro = { fecha: "2026-01-01", monto: 120 };
console.log(tieneCampos(registro, ["fecha", "monto"]));
console.log(tieneCampos(registro, ["fecha", "cliente"]));Los datos pueden estar fuera del rango esperado. Una función de validación ayuda a detectar valores sospechosos.
function fueraDeRango(valor, minimo, maximo) {
return valor < minimo || valor > maximo;
}
const edades = [18, 25, 150, -2, 40];
const sospechosas = edades.filter(edad => fueraDeRango(edad, 0, 120));
console.log(sospechosas);Analizar datos reales suele requerir combinar listas. Por ejemplo, ventas con datos de clientes.
function unirPorId(ventas, clientes) {
return ventas.map(venta => {
const cliente = clientes.find(c => c.id === venta.clienteId);
return {
...venta,
cliente: cliente ? cliente.nombre : "desconocido"
};
});
}
const ventas = [{ clienteId: 1, monto: 100 }, { clienteId: 2, monto: 80 }];
const clientes = [{ id: 1, nombre: "Ana" }];
console.log(unirPorId(ventas, clientes));Una función puede convertir indicadores en una interpretación textual simple.
function conclusionVariacion(variacion) {
if (variacion > 10) {
return "crecimiento fuerte";
}
if (variacion < -10) {
return "caída importante";
}
return "cambio moderado";
}
console.log(conclusionVariacion(18));
console.log(conclusionVariacion(-4));Un flujo completo combina varias funciones pequeñas. Cada una tiene una responsabilidad clara.
function ventasValidas(ventas) {
return ventas.filter(venta => venta.monto > 0);
}
function total(ventas) {
return ventas.reduce((suma, venta) => suma + venta.monto, 0);
}
function resumen(ventas) {
const validas = ventasValidas(ventas);
return {
registros: validas.length,
total: total(validas)
};
}
const ventas = [
{ monto: 100 },
{ monto: -20 },
{ monto: 300 }
];
console.log(resumen(ventas));El análisis de datos mediante funciones se aplica en:
Al analizar datos mediante funciones conviene evitar estos problemas:
Las funciones permiten convertir datos en análisis confiables. Al dividir el proceso en pasos pequeños, cada cálculo se vuelve más claro, reutilizable y verificable.
Analizar datos no es solo producir números: es construir un camino lógico desde los registros originales hasta una interpretación útil para tomar decisiones.