0Pricing
R Academy · Lección

¿Qué es un entorno en R?

Explore los entornos como listas con nombre que contienen referencias a sus padres.

¿Qué es un entorno en R? es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 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.

¿Qué es un entorno?

En R, un entorno es una colección de bindings con nombre (similar a una lista con nombres) junto con un puntero a un entorno principal. Cada variable vive en algún entorno. Cuando R busca un nombre, primero busca en el entorno actual y después recorre la cadena de entornos principales.

# The global environment holds your session variables
x <- 42
cat('x is in globalenv:', exists('x', envir = globalenv()), '\n')
cat('globalenv name:', environmentName(globalenv()), '\n')

globalenv(), baseenv() y emptyenv()

R tiene varios entornos integrados: globalenv() es su espacio de trabajo interactivo, baseenv() contiene las funciones base de R y emptyenv() es la parte superior de la cadena, sin entorno principal. Toda cadena de entornos termina finalmente en emptyenv().

cat('global    :', environmentName(globalenv()),  '\n')
cat('base      :', environmentName(baseenv()),    '\n')
cat('empty     :', environmentName(emptyenv()),   '\n')
cat('parent of global:', environmentName(parent.env(globalenv())), '\n')

La cadena de entornos

Cada entorno tiene exactamente un entorno principal, excepto emptyenv(). Cuando R no encuentra un nombre en el entorno actual, pasa al entorno principal, después al principal de este y así sucesivamente. Esta cadena es la forma en que R resuelve los nombres de las variables.

# Walk the parent chain from globalenv
env <- globalenv()
for (i in 1:5) {
  cat(sprintf('Level %d: %s\n', i, environmentName(env)))
  if (identical(env, emptyenv())) break
  env <- parent.env(env)
}

environment() para una función

Cada función tiene un entorno asociado: aquel en el que se creó. environment(f) devuelve ese entorno. Este es el entorno envolvente de la función y determina dónde busca las variables libres.

f <- function() 'hello'
cat('f was defined in:', environmentName(environment(f)), '\n')

# Inside a function, environment() returns its own env
show_env <- function() {
  cat('my env:', environmentName(environment()), '\n')
}
show_env()

as.list() en un entorno

as.list(env) convierte los bindings de un entorno en una lista con nombres, lo que resulta útil para inspeccionar su contenido mediante programación. Al combinarlo con globalenv(), muestra todas las variables actuales de la sesión.

a <- 10
b <- 'hello'
c_val <- TRUE
# Show current global bindings as list
bindings <- as.list(globalenv())
cat('Names in globalenv:', paste(ls(globalenv()), collapse = ', '), '\n')

ls() — Enumerar el contenido de un entorno

ls() enumera los nombres vinculados en un entorno. De forma predeterminada, muestra el entorno global. Pase envir = e para inspeccionar un entorno específico. Añada all.names = TRUE para incluir los nombres que comienzan por ..

my_env <- new.env(parent = emptyenv())
my_env$x <- 1
my_env$y <- 'two'
my_env$.hidden <- TRUE
cat('Default ls:', ls(envir = my_env), '\n')
cat('All names :', ls(envir = my_env, all.names = TRUE), '\n')

new.env() — Creación de entornos

new.env(parent = e) crea un entorno vacío nuevo con el padre indicado. Use emptyenv() como padre cuando necesite un entorno completamente aislado, sin vinculaciones heredadas.

e <- new.env(parent = emptyenv())
e$name  <- 'Alice'
e$score <- 95
cat('Names:', ls(e), '\n')
cat('Name binding:', e$name, '\n')

Entornos frente a listas

Los entornos se parecen a listas con nombres, pero se comportan de manera diferente: siempre se modifican en el mismo lugar (no se copian al modificarlos), tienen un padre y la búsqueda de nombres se realiza mediante una tabla hash (rápida). Las listas se copian cuando se modifican; los entornos no.

# Environments are reference objects (no copy-on-modify)
e <- new.env(parent = emptyenv())
e$x <- 1
f <- e        # f points to same env, not a copy
f$x <- 99
cat('e$x after modifying through f:', e$x, '\n')

exists() y get() en un entorno

exists('name', envir = e) comprueba si un nombre está vinculado en un entorno (o en sus padres de forma predeterminada). get('name', envir = e) recupera el valor. Ambos aceptan inherits = FALSE para buscar únicamente en el entorno especificado.

e <- new.env(parent = emptyenv())
e$pi_approx <- 3.14159
cat('exists pi_approx:', exists('pi_approx', envir = e), '\n')
cat('exists missing:  ', exists('missing_var', envir = e), '\n')
cat('get pi_approx:   ', get('pi_approx', envir = e), '\n')

environmentName() para entornos integrados

environmentName(env) devuelve el nombre legible de los entornos especiales. Los entornos creados por el usuario devuelven '' (cadena vacía). Esto le ayuda a rastrear dónde se definieron las variables al depurar.

cat(environmentName(globalenv()),    '\n')  # R_GlobalEnv
cat(environmentName(baseenv()),      '\n')  # package:base
cat(environmentName(emptyenv()),     '\n')  # R_EmptyEnv
e <- new.env(parent = emptyenv())
cat('User env name: "', environmentName(e), '"\n', sep = '')

Práctica: uso de entornos como cachés

Como los entornos se modifican en el mismo lugar, funcionan bien como cachés mutables o tablas hash. Almacene los resultados calculados en un entorno para evitar volver a calcularlos; es más rápido que modificar una lista (que se copia).

cache <- new.env(parent = emptyenv(), hash = TRUE)
cached_square <- function(n) {
  key <- as.character(n)
  if (exists(key, envir = cache, inherits = FALSE))
    return(get(key, envir = cache))
  result <- n^2
  assign(key, result, envir = cache)
  result
}
cat(cached_square(7), '\n')
cat(cached_square(7), '\n')  # served from cache

Comprobación rápida

¿Cuál es el entorno situado más arriba en la cadena de entornos de R, es decir, el que no tiene padre?

Entornos: ideas clave

Ideas clave sobre los entornos de R:

  • Un entorno = vinculaciones con nombre + puntero al padre
  • globalenv() = su espacio de trabajo; baseenv() = R base; emptyenv() = final de la cadena
  • La búsqueda de nombres recorre la cadena de padres hasta encontrar el nombre o llegar a emptyenv()
  • ls(envir=e) enumera las vinculaciones; exists() comprueba; get() recupera
  • Los entornos son objetos de referencia: no se copian al modificarlos
  • new.env(parent=emptyenv()) crea un entorno aislado
e <- new.env(parent = emptyenv())
assign('counter', 0L, envir = e)
for (i in 1:5) assign('counter', e$counter + 1L, envir = e)
cat('Counter:', e$counter, '\n')
cat('Env name:', environmentName(e), '\n')
cat('Bindings:', ls(e), '\n')

Preguntas frecuentes

¿La lección «¿Qué es un entorno en R?» es gratis?

Sí — el texto completo de «¿Qué es un entorno en R?» 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 «¿Qué es un entorno en R?»?

Explore los entornos como listas con nombre que contienen referencias a sus padres. 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 1 de 4.

¿Cuánto tiempo toma la lección «¿Qué es un entorno en R?»?

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

  1. ¿Qué es un entorno en R?
  2. Reglas del ámbito léxico
  3. Ámbito global frente a local
  4. Creación e inspección de entornos
← Volver a R Academy