Ámbito global frente a local
Distinga entre .GlobalEnv, los entornos de funciones y los cierres.
Ámbito global frente a local es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
Variables locales en funciones
Las variables asignadas con <- o = dentro del cuerpo de una función son locales a esa función. Se crean en el entorno propio de la función y desaparecen cuando esta devuelve el resultado. Nunca afectan al ámbito desde el que se llamó.
x <- 'global'
f <- function() {
x <- 'local' # creates a new local binding, does not modify global x
cat('Inside f: x =', x, '\n')
}
f()
cat('Outside f: x =', x, '\n') # still 'global'Los parámetros de las funciones son locales
Los parámetros de las funciones también son variables locales. Modificar un parámetro dentro de la función no afecta al argumento en el entorno desde el que se llamó. R pasa los argumentos por valor (con semántica de copia al modificar).
double_it <- function(n) {
n <- n * 2 # modifies local copy only
cat('Inside:', n, '\n')
}
my_n <- 5
double_it(my_n)
cat('Outside:', my_n, '\n') # still 5<<- para asignaciones globales
<<- (superasignación) busca en la cadena de padres y asigna el valor a la primera coincidencia que encuentra. Si no existe ninguna coincidencia, crea la vinculación en el entorno global. Úselo con moderación: el uso excesivo de <<- dificulta razonar sobre las funciones.
total <- 0
add_to_total <- function(x) {
total <<- total + x
}
add_to_total(10)
add_to_total(25)
add_to_total(5)
cat('Total:', total, '\n')<<- busca hacia arriba en la cadena
<<- no asigna directamente al entorno global: recorre la cadena de padres y asigna el valor al primer entorno en el que ya existe el nombre. Si la variable existe en una función envolvente, se actualiza allí.
outer <- function() {
n <- 0
increment <- function() n <<- n + 1
increment()
increment()
cat('n in outer:', n, '\n') # n was in outer's env, updated there
}
outer()
# n does NOT appear in global env
cat('n in global:', exists('n', envir = globalenv()), '\n')assign() para especificar explícitamente el entorno
assign('name', value, envir = e) asigna directamente a un entorno específico. Es más explícito que <<- y resulta útil cuando tiene un objeto de entorno y quiere establecer en él un valor con precisión.
my_env <- new.env(parent = emptyenv())
assign('score', 95, envir = my_env)
assign('name', 'Alice', envir = my_env)
cat('score:', get('score', envir = my_env), '\n')
cat('name :', get('name', envir = my_env), '\n')local() — Bloques de código aislados
local({...}) evalúa una expresión en un entorno local nuevo. Las variables creadas dentro del bloque no se filtran al entorno global. Esto resulta útil para cálculos temporales que no deben contaminar el espacio de trabajo.
result <- local({
temp1 <- 100
temp2 <- 200
temp1 + temp2 # the last expression is returned
})
cat('result:', result, '\n')
cat('temp1 in global:', exists('temp1'), '\n') # FALSElocal() frente a una función para aislar código
Tanto local() como una función invocada inmediatamente proporcionan aislamiento de ámbito. local() es más conciso para un aislamiento puntual; una función con nombre es mejor cuando quiere que la lógica sea reutilizable o comprobable.
# Option A: local()
result_a <- local({
x <- 7
y <- 3
x * y
})
# Option B: immediately invoked function
result_b <- (function() {
x <- 7
y <- 3
x * y
})()
cat(result_a, result_b, '\n')
cat('x in global:', exists('x'), '\n')Lectura de variables globales desde una función
Las funciones pueden leer variables de su ámbito envolvente (global o de otro tipo) sin ninguna sintaxis especial. Es el funcionamiento estándar del ámbito léxico. Sin embargo, depender demasiado del estado global dificulta probar las funciones; cuando sea posible, prefiera argumentos explícitos.
tax_rate <- 0.20 # global configuration
apply_tax <- function(price) {
price * (1 + tax_rate) # reads tax_rate from global
}
cat(apply_tax(100), '\n')
cat(apply_tax(250), '\n')Ocultación de variables
Cuando una variable local tiene el mismo nombre que una global, la vinculación local oculta a la global. Dentro de la función se utiliza la versión local. La global no se modifica. Esto puede causar errores sutiles si ocurre sin intención.
mean <- 99 # shadows base R's mean() function
cat(mean, '\n') # prints 99, not the function
# To call the real mean, use base:: prefix
cat(base::mean(c(1, 2, 3, 4, 5)), '\n')
rm(mean) # remove the shadowEntornos de function()
Cada vez que se llama a una función, R crea un entorno nuevo para esa llamada, cuyo padre es el entorno envolvente de la función. Las variables locales de distintas llamadas no interfieren entre sí, ni siquiera en llamadas recursivas.
factorial_r <- function(n) {
# Each recursive call has its own local n
if (n <= 1) return(1)
n * factorial_r(n - 1)
}
cat('5! =', factorial_r(5), '\n')
cat('7! =', factorial_r(7), '\n')rm() para eliminar variables
rm('name') o rm(name) elimina una vinculación del entorno actual (o del especificado). Úselo para limpiar variables temporales. Pase envir = e para eliminarla de un entorno concreto.
x <- 42
y <- 'hello'
cat('Before rm:', ls(), '\n')
rm(x)
cat('After rm(x):', exists('x'), '\n')
rm('y')
cat('After rm(y):', exists('y'), '\n')Comprobación rápida
¿Qué hace <<- que no haga la asignación normal con <-?
Ámbito: ideas clave
Ideas clave sobre el ámbito global y local:
<-dentro de una función crea una variable local; la global no cambia- Los parámetros de las funciones son locales; R pasa los argumentos por valor (copia al modificar)
<<-recorre la cadena de padres y modifica la primera vinculación coincidenteassign('x', val, envir=e)permite asignar explícitamente en un entornolocal({...})proporciona un ámbito desechable sin crear una función con nombre- Evite ocultar nombres importantes (como
mean,c,T)
# Demonstrate local + <<- cleanly
running_sum <- 0
local({
values <- c(10, 20, 30, 40)
for (v in values) running_sum <<- running_sum + v
})
cat('Running sum:', running_sum, '\n')
cat('values in global:', exists('values'), '\n')Preguntas frecuentes
¿La lección «Ámbito global frente a local» es gratis?
Sí — el texto completo de «Ámbito global frente a local» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Ámbito global frente a local»?
Distinga entre .GlobalEnv, los entornos de funciones y los cierres. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Ámbito global frente a local»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- ¿Qué es un entorno en R?
- Reglas del ámbito léxico
- Ámbito global frente a local
- Creación e inspección de entornos