En software real no basta con saber escribir funciones. También hay que interpretarlas: entender qué reciben, qué devuelven, qué unidades usan, qué límites tienen y qué comportamiento representan.
Una función puede parecer simple en el código, pero estar expresando una regla de negocio, una fórmula física, un criterio de seguridad, una transformación gráfica o una decisión automática.
Una función puede interpretarse como un contrato: si se entregan ciertas entradas válidas, se obtiene una salida con significado definido.
function calcularTotal(precio, cantidad) {
return precio * cantidad;
}
console.log(calcularTotal(120, 3));El contrato implícito es que precio y cantidad son números, y que la salida representa un importe total.
El primer paso para interpretar una función es reconocer qué datos necesita. Los nombres de parámetros dan pistas, pero no siempre son suficientes.
function calcularEnvio(pesoKg, distanciaKm) {
return 300 + pesoKg * 80 + distanciaKm * 5;
}
console.log(calcularEnvio(2.5, 40));Aquí las unidades están en los nombres: kilogramos y kilómetros. Eso reduce errores de interpretación.
También hay que entender qué representa el valor devuelto. Dos funciones pueden devolver números, pero esos números pueden significar cosas muy distintas.
function porcentajeUso(usado, total) {
return usado / total * 100;
}
const uso = porcentajeUso(64, 128);
console.log("Uso:", uso, "%");La salida no es una fracción entre 0 y 1, sino un porcentaje entre 0 y 100.
Muchos errores aparecen cuando una función espera una unidad y recibe otra. Una función puede usar segundos, milisegundos, metros, píxeles, porcentajes o valores normalizados.
function distancia(velocidadMetrosPorSegundo, tiempoSegundos) {
return velocidadMetrosPorSegundo * tiempoSegundos;
}
console.log(distancia(10, 5), "metros");Si el tiempo se pasara en milisegundos sin convertir, el resultado sería incorrecto.
El dominio de una función es el conjunto de entradas que tienen sentido. En software, el dominio debe controlarse para evitar resultados inválidos.
function raizSegura(x) {
if (x < 0) {
return null;
}
return Math.sqrt(x);
}
console.log(raizSegura(25));
console.log(raizSegura(-4));Los casos límite son entradas en los bordes del dominio: cero, máximo, mínimo, lista vacía, texto vacío o valores extremos.
function promedio(datos) {
if (datos.length === 0) {
return 0;
}
return datos.reduce((total, valor) => total + valor, 0) / datos.length;
}
console.log(promedio([]));
console.log(promedio([10, 20]));Interpretar una función incluye saber qué ocurre cuando recibe entradas poco comunes.
Una función pura depende solamente de sus entradas y no modifica datos externos. Esto facilita su interpretación.
function aplicarDescuento(precio, porcentaje) {
return precio * (1 - porcentaje / 100);
}
console.log(aplicarDescuento(1000, 15));
console.log(aplicarDescuento(1000, 15));Para la misma entrada, la salida siempre es la misma.
Algunas funciones dependen de valores externos. Interpretarlas requiere mirar más allá de los parámetros.
let impuesto = 21;
function precioConImpuesto(precio) {
return precio * (1 + impuesto / 100);
}
console.log(precioConImpuesto(100));
impuesto = 10.5;
console.log(precioConImpuesto(100));La función parece recibir solo precio, pero también depende de impuesto.
Los nombres deben ayudar a entender intención. Una función llamada calcular dice poco; una llamada calcularInteresMensual comunica mucho más.
function calcularInteresMensual(capital, tasaAnual) {
return capital * (tasaAnual / 100) / 12;
}
console.log(calcularInteresMensual(100000, 36));Muchas funciones reales tienen forma lineal. En software suelen usarse para tarifas, costos, escalas o conversiones.
function tarifaTaxi(km) {
const bajadaBandera = 800;
const precioPorKm = 250;
return bajadaBandera + km * precioPorKm;
}
console.log(tarifaTaxi(0));
console.log(tarifaTaxi(8));La salida crece de manera constante a medida que aumenta la distancia.
En sistemas reales, muchas reglas cambian según rangos. Esto produce funciones por tramos.
function costoEnvio(montoCompra) {
if (montoCompra >= 50000) {
return 0;
}
if (montoCompra >= 20000) {
return 1200;
}
return 2500;
}
console.log(costoEnvio(15000));
console.log(costoEnvio(25000));
console.log(costoEnvio(70000));Una función de validación no calcula una magnitud, sino que responde si un dato cumple una regla.
function esContrasenaValida(texto) {
return texto.length >= 8 && /\d/.test(texto);
}
console.log(esContrasenaValida("abc"));
console.log(esContrasenaValida("clave123"));La salida es booleana: true o false.
Normalizar es transformar valores a una escala común. Hay que saber si la salida queda entre 0 y 1, entre 0 y 100 o en otra escala.
function normalizar(valor, minimo, maximo) {
return (valor - minimo) / (maximo - minimo);
}
console.log(normalizar(75, 50, 100));Una función de mapeo convierte valores de un intervalo a otro. Es frecuente en gráficos, sensores, animaciones y controles.
function mapear(valor, minOrigen, maxOrigen, minDestino, maxDestino) {
const proporcion = (valor - minOrigen) / (maxOrigen - minOrigen);
return minDestino + proporcion * (maxDestino - minDestino);
}
console.log(mapear(25, 0, 100, 0, 400));Las funciones de puntuación combinan factores para ordenar opciones. No siempre devuelven una unidad física; a veces devuelven un valor relativo.
function puntajeBusqueda(resultado) {
return resultado.coincidencias * 10 + resultado.popularidad * 0.5 - resultado.antiguedadDias * 0.1;
}
const resultado = { coincidencias: 4, popularidad: 80, antiguedadDias: 30 };
console.log(puntajeBusqueda(resultado));El número sirve para comparar resultados, no necesariamente para mostrarlo al usuario.
El redondeo cambia la precisión de una salida. En dinero, estadísticas o mediciones, elegir mal el redondeo puede afectar el resultado final.
function redondearADosDecimales(valor) {
return Math.round(valor * 100) / 100;
}
console.log(redondearADosDecimales(10.236));
console.log(redondearADosDecimales(10.235));Las funciones que trabajan con tiempo deben aclarar si usan segundos, milisegundos, días calendario o días exactos de 24 horas.
function segundosAMilisegundos(segundos) {
return segundos * 1000;
}
function minutosASegundos(minutos) {
return minutos * 60;
}
console.log(segundosAMilisegundos(3));
console.log(minutosASegundos(2));Algunas funciones no solo devuelven un valor: también modifican una variable, escriben en pantalla, guardan datos o envían información.
const historial = [];
function registrarEvento(evento) {
historial.push(evento);
return historial.length;
}
console.log(registrarEvento("inicio"));
console.log(registrarEvento("compra"));
console.log(historial);Interpretar esta función exige notar que cambia el arreglo historial.
Una función real puede devolver un valor especial, lanzar un error o usar un objeto de resultado cuando algo sale mal.
function dividir(a, b) {
if (b === 0) {
return { ok: false, error: "No se puede dividir por cero" };
}
return { ok: true, valor: a / b };
}
console.log(dividir(10, 2));
console.log(dividir(10, 0));Los ejemplos de uso y las pruebas ayudan a interpretar qué espera una función y qué debe devolver.
function esPar(numero) {
return numero % 2 === 0;
}
console.log(esPar(4) === true);
console.log(esPar(7) === false);
console.log(esPar(0) === true);Las pruebas muestran casos normales y casos límite.
Al encontrar una función en un proyecto real, conviene hacerse estas preguntas:
Al interpretar funciones reales, los errores más frecuentes son:
Interpretar funciones reales es una habilidad práctica: permite leer código existente, detectar errores, modificar sistemas con más seguridad y comunicar reglas de negocio o fórmulas técnicas con claridad.
Una función bien entendida no es solo una caja que devuelve algo. Es una relación entre entradas, reglas, límites, unidades y consecuencias dentro de un programa.