¿Qué son y por qué importan?
En programación, una función es un bloque de instrucciones que recibe datos de entrada (parámetros), realiza un cálculo y devuelve un valor. Un procedimiento (también llamado subrutina) ejecuta una acción pero no devuelve un valor. En Programación Orientada a Objetos (POO), un método es una función o un procedimiento asociado a un objeto o a una clase: si devuelve un valor, ese método se comporta como función; si no, es un procedimiento (a menudo llamado "void"). En el lenguaje cotidiano, muchas personas dicen "función" para referirse a cualquier subrutina, incluso cuando no devuelve valor; conviene distinguir el concepto para escribir y leer código con precisión.
| Característica | Función | Procedimiento | Método (POO) |
|---|---|---|---|
| ¿Devuelve valor? | Sí (con return) | No (solo ejecuta acciones) | Depende: puede devolver valor (función-método) o no (void) |
| ¿Se usa en expresiones? | Sí: total = precioConImpuesto(x) | No: se invoca como instrucción | Sí, si devuelve valor; si no, se invoca como instrucción |
| ¿Pertenece a…? | Módulo/archivo | Módulo/archivo | Objeto o clase (accede a su contexto) |
| ¿Acceso a estado? | Solo lo recibido por parámetros/ámbito | Puede tener efectos sobre estado externo (I/O, logs) | Accede a this y al estado del objeto (encapsulación) |
| ¿Ideal para…? | Cálculos, validaciones, transformaciones | Mensajes, registros, cambios de estado externo | Encapsular reglas del dominio y comportamiento del objeto |
| ¿Nombre recomendado? | Sustantivo/verbo que denote resultado: calcular, obtener | Verbo imperativo: imprimir, guardar, enviar | Verbo que describa responsabilidad del objeto: actualizarSaldo, aplicarDescuento |
| ¿Pruebas unitarias? | Más fácil (mismo input → mismo output) | Requieren verificar efectos (p. ej., salida por pantalla) | Se testean como función/procedimiento + estado del objeto/dobles (mocks) |
Anatomía de una función, un procedimiento y un método
// Función: devuelve un valor (retorna número)
function convertirCelsiusAFahrenheit(celsius) {
return (celsius * 9 / 5) + 32;
}
// Procedimiento: realiza una acción visible (no retorna)
function mostrarFahrenheit(celsius) {
const fahrenheit = convertirCelsiusAFahrenheit(celsius);
console.log("Temperatura: " + fahrenheit + " °F");
}
// Método: asociado a un objeto; puede ser función o procedimiento
const Termometro = {
// método-función (devuelve valor)
convertir(celsius) {
return (celsius * 9 / 5) + 32;
},
// método-procedimiento (sin retorno)
mostrar(celsius) {
console.log("Temperatura: " + this.convertir(celsius) + " °F");
}
};
// Ejemplo de uso
const f = convertirCelsiusAFahrenheit(25);
mostrarFahrenheit(25);
Termometro.mostrar(25);Método en 4 pasos para reutilizar código repetido
- Detectá la repetición: buscá bloques iguales o muy similares que copiaste y pegaste.
- Aislá lo que cambia: valores literales (números, textos) que varían entre casos.
- Diseñá la interfaz: convertí lo que cambia en parámetros y definí si necesitás un resultado (función) o solo una acción (procedimiento). Si está dentro de una clase/objeto, será un método.
- Extraé y reemplazá: creá el bloque reutilizable y reemplazá las copias por llamadas.
// Antes: mismos cálculos repetidos (mal)
let precio1 = 100; let total1 = precio1 + precio1 * 0.21;
let precio2 = 250; let total2 = precio2 + precio2 * 0.21;
// Después: función reutilizable (mejor)
function precioConIVA(precio, ivaPorc) {
return precio + precio * ivaPorc; // función: devuelve un número
}
const total1b = precioConIVA(100, 0.21);
const total2b = precioConIVA(250, 0.21);
// Variante POO: método dentro de un objeto
const Facturacion = {
precioConIVA(precio, ivaPorc) {
return precio + precio * ivaPorc; // método-función
}
};
const total3 = Facturacion.precioConIVA(400, 0.105);Ejemplos prácticos
1) Función: calcular precio final con impuestos y descuento
def precio_final(base: float, iva: float, descuento: float) -> float:
# base: precio sin impuestos
# iva: porcentaje en decimal (ej. 0.21)
# descuento: porcentaje en decimal aplicado al final
subtotal = base + base * iva
total = subtotal - subtotal * descuento
return round(total, 2)
monto = precio_final(100.0, 0.21, 0.10) # 100 + 21% luego -10%
print(monto)2) Procedimiento (método-void): mostrar saludo personalizado
public class Saludos {
// Procedimiento: no devuelve valor (void)
public static void mostrarSaludo(String nombre, String momento) {
System.out.println("Hola, " + nombre + ". ¡Buen " + momento + "!");
}
public static void main(String[] args) {
mostrarSaludo("Abby", "día");
}
}3) Función booleana: validar longitud mínima de contraseña
function tieneLongitudMinima(pass, min) {
return pass.length >= min; // true o false
}
if (tieneLongitudMinima("secreto123", 8)) {
console.log("Contraseña válida");
} else {
console.log("Demasiado corta");
}Parámetros, retorno y alcance: lo esencial
Los parámetros son los datos que tu función/procedimiento/método necesita para trabajar. El valor de retorno es el resultado que entrega una función (o un método-función) al final. El alcance (scope) define dónde “viven” las variables. Las variables definidas dentro de una función/procedimiento/método son locales: solo existen allí y no interfieren con otras partes del programa. Mantener variables locales minimiza efectos colaterales y hace tu código más predecible.
Errores comunes y cómo evitarlos
- Mezclar cálculo con presentación: separá funciones (cálculo) de procedimientos (mostrar).
- Olvidar return en una función: el resultado quedará indefinido o por defecto.
- Usar datos globales innecesarios: preferí pasar parámetros explícitos.
- Nombres poco claros: calcularPrecioConIVA es mejor que calc1.
- Hacer demasiado: cada función/método debe tener una sola responsabilidad.
Checklist rápido: ¿función, procedimiento o método?
- ¿Necesitás un número, texto o booleano como resultado? → Función (o método-función).
- ¿Querés imprimir, guardar o notificar algo? → Procedimiento (o método-procedimiento).
- ¿El bloque se usa dentro de una expresión (p. ej., una fórmula)? → Función (o método-función).
- ¿El bloque es una instrucción completa (p. ej., mostrarSaludo(...))? → Procedimiento (o método-procedimiento).
- ¿Debe acceder/modificar el estado de un objeto? → Método (con o sin retorno).
Preguntas frecuentes (Q&A)
¿Puedo llamar a una función desde un procedimiento o un método?
Sí. Es común que un procedimiento o un método llame a una función para calcular un resultado y luego lo muestre o lo use para ejecutar otra acción. Por ejemplo, mostrarFahrenheit(celsius) llama a convertirCelsiusAFahrenheit(celsius) y luego imprime el valor.
¿Qué es exactamente un método?
Es una subrutina asociada a un objeto o clase. Puede comportarse como función (devuelve valor) o como procedimiento (no devuelve). La ventaja es que puede acceder al estado del objeto (this) y encapsular reglas del dominio.
¿Cuándo conviene devolver true/false en lugar de un texto?
Usá booleanos cuando la respuesta sea una validación (sí/no, válido/inválido). Esto permite combinar la función/método en condiciones (if) o en otras expresiones. Si devolvés un texto, limitás la reutilización porque dependés del idioma o del formato del mensaje.
¿Qué pasa si necesito dos resultados distintos?
Con lo visto hasta ahora (sin estructuras complejas), devolvé el resultado principal y, si hace falta, creá una segunda función para calcular el dato complementario. Otra opción es diseñar una función por cada resultado relevante, manteniendo la responsabilidad única y claridad.
¿Es mala práctica que un procedimiento o método modifique variables globales?
No siempre, pero es riesgoso: puede generar efectos colaterales difíciles de rastrear. Preferí pasar parámetros y devolver valores (en funciones/métodos) o, si se trata de un procedimiento/método-void, limitar la modificación de estado a lo estrictamente necesario y documentarlo.
¿Cómo pruebo mis funciones/métodos sin herramientas avanzadas?
Elegí 2–3 valores de entrada y calculá a mano el resultado esperado. Luego ejecutá la función o método con esos valores y compará. Por ejemplo, precio_final(100, 0.21, 0.10) debería dar 98.1 (aprox., según redondeo). Si coincide, vas bien; si no, revisá el orden de operaciones y el return.
Pequeño mapa para nombrar y documentar
- Nombre claro y específico: obtener, calcular, validar, formatear.
- Descripción breve arriba del bloque: qué hace, qué recibe, qué devuelve.
- Ejemplo de uso en un comentario: ayuda a recordar cómo llamarlo.
- Evitá abreviaturas confusas: pensá en la persona que leerá tu código mañana.
Cierre y siguiente paso
Dominar funciones, procedimientos y métodos es la base para proyectos más grandes. Con el método (proceso) de 4 pasos y ejemplos simples, podés empezar a refactorizar tus programas desde hoy. En el siguiente nivel, aprenderás a combinar estas piezas con estructuras como colecciones, para resolver problemas más complejos manteniendo tu código limpio y reutilizable.