🧠 Funciones y módulos

A medida que los programas crecen, necesitan orden y estructura.
Para eso existen las funciones y los módulos, que permiten dividir la lógica en piezas pequeñas, comprensibles y reutilizables.

Programar no es solo escribir código,
es organizar el pensamiento para que el sistema pueda entenderlo.

🔹 Qué es una función

Una función es un bloque de código que cumple una tarea específica.
Se define una vez y puede ejecutarse muchas veces.

Estructura general

🔹 Ejemplo comparativo

🐍 Python

def sumar(a, b):
    return a + b
 
resultado = sumar(5, 3)
print("Resultado:", resultado)

⚡ JavaScript

function sumar(a, b) {
    return a + b;
}
 
let resultado = sumar(5, 3);
console.log("Resultado:", resultado);

🐹 Go

package main
import "fmt"
 
func sumar(a int, b int) int {
    return a + b
}
 
func main() {
    resultado := sumar(5, 3)
    fmt.Println("Resultado:", resultado)
}

Una función permite nombrar una acción lógica y reutilizarla en distintos lugares del programa.

🔹 Parámetros y retorno

Las funciones pueden recibir datos y devolver resultados.
Eso les da independencia y flexibilidad.

def convertir(grados):
    return grados * 9/5 + 32

function convertir(grados) {
    return grados * 9/5 + 32;
}

func convertir(grados float64) float64 {
    return grados*9/5 + 32
}

La entrada y salida de datos en una función son como el flujo lógico de información.

🔹 Modularidad: dividir para comprender

A medida que los programas crecen, es imposible mantener todo el código en un solo archivo.
Los módulos permiten dividir el programa en partes y luego importarlas según necesidad.

Un módulo es simplemente un archivo que contiene funciones o definiciones reutilizables.

🔹 Importación de módulos

Cada lenguaje tiene su propia forma de importar funciones desde otros archivos o bibliotecas.

🐍 Python

# archivo: operaciones.py
def sumar(a, b):
    return a + b
 
# archivo principal
from operaciones import sumar
print(sumar(2, 3))

⚡ JavaScript (Node.js)

// archivo: operaciones.js
export function sumar(a, b) {
  return a + b;
}
 
// archivo principal
import { sumar } from "./operaciones.js";
console.log(sumar(2, 3));

🐹 Go

// archivo: operaciones/operaciones.go
package operaciones
 
func Sumar(a int, b int) int {
    return a + b
}
 
// archivo principal
package main
import (
    "fmt"
    "operaciones"
)
func main() {
    fmt.Println(operaciones.Sumar(2, 3))
}

Importar un módulo es invocar la lógica escrita en otro lugar.

🔹 Módulos estándar y externos

Los lenguajes incluyen bibliotecas estándar (ya integradas)
y permiten añadir paquetes externos para extender sus capacidades.

Aprender a usar bibliotecas existentes es tan importante como escribir funciones propias.

🔹 Ejemplo integrador

Supongamos un programa que calcula áreas de figuras simples.

🐍 Python

# archivo: figuras.py
def area_rectangulo(base, altura):
    return base * altura
 
# archivo principal
from figuras import area_rectangulo
print("Área:", area_rectangulo(5, 3))

⚡ JavaScript

// archivo: figuras.js
export function areaRectangulo(base, altura) {
  return base * altura;
}
 
// archivo principal
import { areaRectangulo } from "./figuras.js";
console.log("Área:", areaRectangulo(5, 3));

🐹 Go

// archivo: figuras/figuras.go
package figuras
 
func AreaRectangulo(base, altura float64) float64 {
    return base * altura
}
 
// archivo principal
package main
import (
    "fmt"
    "figuras"
)
func main() {
    fmt.Println("Área:", figuras.AreaRectangulo(5, 3))
}

La modularidad permite construir programas grandes a partir de piezas simples y bien definidas.

🧭 Conclusión

Las funciones y módulos son la base de la programación estructurada.
Permiten dividir los problemas complejos en partes pequeñas, comprensibles y reutilizables.

Un buen programador no escribe mucho código:
reutiliza y organiza el que ya existe.