0Pricing
R Academy · Lección

Creación e inspección de entornos

Use new.env(), environment(), ls() y get() para trabajar con entornos.

Creación e inspección de entornos es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 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.

Creación de un entorno nuevo

new.env(parent = e) crea un entorno vacío nuevo. El argumento parent establece qué entorno se busca cuando no se encuentra un nombre en el nuevo. Use emptyenv() para obtener un entorno completamente aislado.

# Isolated environment (no parent chain)
e1 <- new.env(parent = emptyenv())
# Environment with global as parent
e2 <- new.env(parent = globalenv())
cat('e1 parent:', environmentName(parent.env(e1)), '\n')
cat('e2 parent:', environmentName(parent.env(e2)), '\n')

assign() — Añadir vinculaciones

assign('name', value, envir = e) crea o actualiza una vinculación con nombre en el entorno especificado. Es el equivalente programático de e$name <- value, pero funciona cuando el nombre está almacenado en una variable.

e <- new.env(parent = emptyenv())
assign('x', 10, envir = e)
assign('y', 'hello', envir = e)
assign('z', TRUE, envir = e)
cat('x:', get('x', envir = e), '\n')
cat('y:', get('y', envir = e), '\n')

get() y mget()

get('name', envir = e) recupera una sola vinculación. mget(c('a','b'), envir = e) recupera varias vinculaciones a la vez y devuelve una lista con nombres. Ambos producen un error si el nombre no existe (a menos que inherits permita buscar en la cadena).

e <- new.env(parent = emptyenv())
e$alpha <- 1
e$beta  <- 2
e$gamma <- 3
# Single
get('alpha', envir = e)
# Multiple
mget(c('alpha', 'beta', 'gamma'), envir = e)

ls() — Enumerar vinculaciones

ls(envir = e) devuelve un vector de caracteres con todos los nombres vinculados en el entorno e. Añada all.names = TRUE para incluir los nombres que empiezan por . (ocultos de forma predeterminada). Los nombres se devuelven en orden alfabético.

e <- new.env(parent = emptyenv())
e$b_val  <- 2
e$a_val  <- 1
e$.secret <- 'hidden'
cat('Default ls:', ls(envir = e), '\n')
cat('All names :', ls(envir = e, all.names = TRUE), '\n')

exists() con inherits

exists('name', envir = e, inherits = FALSE) comprueba únicamente el entorno especificado, no sus padres. Con inherits = TRUE (valor predeterminado), también busca en la cadena de padres. Use inherits = FALSE para comprobaciones locales estrictas.

parent_e <- new.env(parent = emptyenv())
parent_e$shared <- 42
child_e  <- new.env(parent = parent_e)
# inherits=TRUE: finds shared in parent
cat('inherits TRUE:', exists('shared', envir = child_e, inherits = TRUE),  '\n')
# inherits=FALSE: only looks in child
cat('inherits FALSE:', exists('shared', envir = child_e, inherits = FALSE), '\n')

environmentName() y parent.env()

environmentName(e) devuelve el nombre de un entorno integrado ('R_GlobalEnv', 'package:base', etc.). Los entornos creados por el usuario devuelven ''. parent.env(e) devuelve el objeto de entorno padre.

e <- new.env(parent = globalenv())
cat('Name of e     :', environmentName(e), '\n')
cat('Parent of e   :', environmentName(parent.env(e)), '\n')
cat('Name of global:', environmentName(globalenv()), '\n')

Sintaxis $ para entornos

Los entornos admiten la sintaxis $ y [[, al igual que las listas, para leer y escribir vinculaciones. Suele ser más cómodo que get()/assign() para acceder directamente cuando se conoce el nombre al escribirlo.

e <- new.env(parent = emptyenv())
e$pi_approx <- 3.14159
e[['e_approx']] <- 2.71828
cat('pi:', e$pi_approx, '\n')
cat('e :', e[['e_approx']], '\n')

rm() en un entorno específico

rm('name', envir = e) elimina una vinculación de un entorno específico. Esto es diferente de eliminar una variable global: al trabajar con entornos personalizados, debe especificar explícitamente el entorno.

e <- new.env(parent = emptyenv())
e$keep <- 1
e$remove_me <- 99
cat('Before:', ls(envir = e), '\n')
rm('remove_me', envir = e)
cat('After :', ls(envir = e), '\n')

as.list() para volcar un entorno

as.list(e) convierte todas las vinculaciones de un entorno en una lista con nombres, lo que facilita inspeccionar o serializar su contenido. El resultado es una instantánea: los cambios posteriores en el entorno no se reflejan en la lista.

e <- new.env(parent = emptyenv())
e$x <- 10
e$y <- 20
e$z <- 30
bindings <- as.list(e)
cat('Class:', class(bindings), '\n')
cat('Length:', length(bindings), '\n')
str(bindings)

Entornos como tablas hash

La opción hash = TRUE de new.env() (predeterminada cuando se establece el padre) activa la búsqueda basada en hash, por lo que la búsqueda de nombres es O(1). Esto hace que los entornos grandes sean mucho más rápidos que las listas para almacenar pares clave-valor.

# Build a small key-value store
store <- new.env(hash = TRUE, parent = emptyenv())
keys   <- paste0('key_', 1:5)
values <- c(10, 20, 30, 40, 50)
for (i in seq_along(keys)) assign(keys[i], values[i], envir = store)
# Retrieve
cat('key_3 =', get('key_3', envir = store), '\n')
cat('All keys:', ls(store), '\n')

Copiar y compartir entornos

Asignar un entorno a una variable nueva no lo copia: ambas variables hacen referencia al mismo objeto. Use as.list() y después list2env() para crear una copia real si necesita entornos independientes.

e1 <- new.env(parent = emptyenv())
e1$val <- 100
e2 <- e1          # reference, not a copy
e2$val <- 999
cat('e1$val:', e1$val, '\n')  # 999, modified via e2!

# True copy:
e3 <- list2env(as.list(e1), parent = emptyenv())
e3$val <- 0
cat('e1$val after e3 change:', e1$val, '\n')  # still 999

Comprobación rápida

¿Qué función comprueba si un nombre está vinculado en un entorno sin buscar en sus entornos padre?

Creación de entornos: conclusiones clave

Conclusiones clave para crear e inspeccionar entornos:

  • new.env(parent=e) crea un entorno nuevo y vacío; use hash=TRUE para almacenes grandes
  • assign('x', v, envir=e) y get('x', envir=e) permiten el acceso mediante programación
  • e$x y e[['x']] funcionan como accesores de listas
  • ls(envir=e) muestra los nombres; use exists('x', envir=e, inherits=FALSE) para una comprobación estricta
  • as.list(e) vuelca el entorno en una lista; list2env() lo reconstruye
  • Los entornos son objetos de referencia: la asignación los comparte, no los copia
config <- new.env(hash = TRUE, parent = emptyenv())
assign('host', 'localhost', envir = config)
assign('port', 5432L,       envir = config)
assign('db',   'mydb',      envir = config)
cat('Keys  :', ls(config), '\n')
cat('host  :', config$host, '\n')
cat('port  :', config$port, '\n')

Preguntas frecuentes

¿La lección «Creación e inspección de entornos» es gratis?

Sí — el texto completo de «Creación e inspección de entornos» 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 «Creación e inspección de entornos»?

Use new.env(), environment(), ls() y get() para trabajar con entornos. 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 4 de 4.

¿Cuánto tiempo toma la lección «Creación e inspección de entornos»?

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