Qué es el ámbito (scope) y por qué importa
El ámbito —o alcance— define desde qué partes del programa podés ver y usar una variable. Entenderlo te evita errores difíciles de depurar, hace tu código más predecible y facilita las pruebas. Hay reglas de visibilidad a nivel de archivo (o módulo) y a nivel de bloque (por ejemplo, dentro de llaves { } o de una indentación en Python). También conviene diferenciar el alcance (dónde se ve el nombre) del tiempo de vida (cuánto tiempo existe el valor en memoria).
Dos ideas clave
- Visibilidad: dónde puede referenciarse una variable (archivo/módulo, bloque). Un nombre sólo es “alcanzable” dentro del ámbito en el que fue declarado.
- Tiempo de vida: cuánto dura la variable. Puede existir sólo mientras se ejecuta cierto bloque o durante toda la ejecución del programa (por ejemplo, una constante definida al inicio del archivo).
Local vs global (o de archivo/módulo)
Variables locales: están encerradas en un bloque (por ejemplo, entre llaves en JS/TS) y nadie fuera de ese bloque puede accederlas. Variables globales/de archivo: viven en el archivo (o módulo) y son visibles desde cualquier bloque dentro de ese archivo. Las globales facilitan el acceso, pero si son mutables pueden generar efectos colaterales y dificultar el mantenimiento. Como regla práctica: preferí datos locales (limitados al bloque) y convertí en constantes los valores compartidos que no cambian.
- Usá locales para valores temporales, contadores de un bloque y resultados intermedios.
- Usá globales/de archivo sólo si son constantes o configuración inmutable.
- Evitá globales mutables: hacen el código frágil, sobre todo cuando crece el proyecto.
Ejemplos paso a paso
JavaScript/TypeScript: bloque vs archivo
// Archivo: demo.ts (módulo ESM)
const APP_NAME = "MiApp"; // constante de archivo (compartida dentro del archivo)
let a = 1; // variable de archivo
if (true) { // bloque
let a = 2; // 'a' del bloque (shadowing, leer mas abajo en las FAQs)
var b = 3; // 'var' no respeta el bloque
const C = 4; // 'C' vive sólo dentro del bloque
console.log(a); // 2 (la del bloque)
}
console.log(a); // 1 (la del archivo)
// console.log(C); // ❌ Error: C no está definida aquí
console.log(b); // 3 ('var' se “escapa” del bloque)En JS/TS moderno, let y const respetan el alcance de bloque: sólo existen dentro de las llaves. En cambio, var se eleva al ámbito de archivo y queda visible fuera del bloque. Este detalle provoca errores comunes: preferí let/const para evitar fugas de variables.
Python: los bloques no crean nuevo ámbito
APP_NAME = "MiApp" # constante por convención (mayúsculas)
a = 1 # variable del archivo
if True: # bloque por indentación
a = 2 # reasigna la misma 'a' del archivo
b = 3 # 'b' también vive en el archivo
print(a) # 2
print(b) # 3En Python, los bloques if/for/while no crean un nuevo ámbito de nombres: si declarás variables adentro, siguen siendo del archivo. Por eso, es importante elegir nombres claros y evitar reusar el mismo nombre si cambia el propósito. Para constantes, usá MAYÚSCULAS por convención.
Patrones simples para evitar globales accidentales
- Agrupá configuración en constantes de archivo con nombres explícitos (p. ej., APP_NAME, API_BASE).
- Usá let/const (JS/TS) dentro de bloques para limitar el alcance y evitar colisiones.
- En Python, sé intencional con los nombres en el archivo; un bloque no aísla nombres.
- Evitá reusar el mismo identificador con otro significado (shadowing) si puede confundir.
- Documentá cerca de la declaración qué se espera (mutable/inmutable, quién lo puede cambiar).
Tabla comparativa rápida
| Lenguaje | Ámbito de bloque | Ámbito de archivo/módulo | Nota para principiantes |
|---|---|---|---|
| JavaScript/TypeScript | let/const viven sólo dentro de { } | Variables de módulo (archivo). 'var' ignora el bloque | Preferí let/const. Evitá var para no “fugar” nombres. |
| Python | if/for/while NO crean nuevo ámbito | Nombres del archivo visibles en todo el archivo | Elegí nombres claros; un bloque no aísla variables. |
| Java | Bloques { } aíslan nombres | No hay “globales” de archivo; se usan campos/constantes de clase | Pensá en constantes de clase (final). Evitá estado compartido mutable. |
| C++ | Bloques { } aíslan nombres | Sí existen globales a nivel archivo | Preferí const y limitá globales mutables; documentá su uso. |
Mini-ejercicio guiado
- Leé el ejemplo de JS/TS: identificá qué nombres existen sólo en el bloque y cuáles quedan en el archivo.
- Escribí un bloque nuevo con let x y const Y; comprobá que fuera del bloque no existen.
- En Python, creá un if True con una variable nueva z y verificá que luego podés imprimir z fuera del bloque.
Solución esperada: en JS/TS, let/const del bloque no son visibles fuera; var sí. En Python, las variables creadas en el if se mantienen visibles en el archivo.
Preguntas frecuentes (FAQ)
¿Las variables globales son siempre malas?
No. Las constantes globales o de archivo (inmutables) son muy útiles para configuración y valores fijos. El problema aparece con globales mutables: su valor puede cambiar en cualquier parte del archivo y generar efectos no deseados. Si algo cambia seguido, mantenelo en el bloque que realmente lo necesita.
¿Qué es el shadowing (sombra) y por qué confunde?
Es cuando un nombre interno oculta otro con el mismo nombre en un ámbito más externo. En JS/TS, "let a" dentro de un bloque puede “tapar” a "a" del archivo. Evitalo usando nombres más específicos (por ejemplo, totalBloque en lugar de total) y manteniendo las variables lo más cerca posible de donde se usan.
¿Cómo evito crear globales accidentales?
- En JS/TS, declarando SIEMPRE con let o const (nunca un nombre “suelto”).
- En Python, siendo explícito con los nombres y comentando la intención cerca de la declaración.
- Usando constantes para todo lo que no cambia (APP_NAME, VERSION, RUTAS).
¿Cuál es la diferencia práctica entre alcance y tiempo de vida?
El alcance responde “¿desde dónde puedo usar este nombre?”. El tiempo de vida responde “¿cuándo deja de existir el valor?”. Podés tener una variable visible sólo en un bloque cuyo valor deja de existir al salir de ese bloque, y otra constante visible en todo el archivo durante toda la ejecución.