0Pricing
R Academy · Aula

Criando e inspecionando ambientes

Use new.env(), environment(), ls() e get() para trabalhar com ambientes.

Criando e inspecionando ambientes é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Criando um novo ambiente

new.env(parent = e) cria um ambiente vazio. O argumento parent define qual ambiente será pesquisado quando um nome não for encontrado no novo ambiente. Use emptyenv() para obter um ambiente totalmente isolado.

# 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() — adicionando vínculos

assign('name', value, envir = e) cria ou atualiza um vínculo nomeado no ambiente especificado. É o equivalente programático de e$name <- value, mas funciona quando o nome está armazenado em uma variável.

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() e mget()

get('name', envir = e) recupera um único vínculo. mget(c('a','b'), envir = e) recupera vários vínculos de uma só vez, retornando uma lista nomeada. Ambos geram um erro se o nome não existir (a menos que inherits permita pesquisar a cadeia).

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() — listando vínculos

ls(envir = e) retorna um vetor de character com todos os nomes associados ao ambiente e. Adicione all.names = TRUE para incluir nomes que começam com . (ocultos por padrão). Os nomes são retornados em ordem alfabética.

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() com inherits

exists('name', envir = e, inherits = FALSE) verifica apenas o ambiente especificado, não seus pais. Com inherits = TRUE (padrão), também pesquisa a cadeia de pais. Use inherits = FALSE para verificações locais estritas.

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() e parent.env()

environmentName(e) retorna o nome de um ambiente integrado ('R_GlobalEnv', 'package:base', etc.). Ambientes criados pelo usuário retornam ''. parent.env(e) retorna o objeto de ambiente pai.

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')

Sintaxe $ para ambientes

Os ambientes aceitam a sintaxe $ e [[, assim como as listas, para ler e escrever vínculos. Isso costuma ser mais conveniente do que get()/assign() para acesso direto quando o nome é conhecido no momento da escrita.

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() em um ambiente específico

rm('name', envir = e) remove um vínculo de um ambiente específico. Isso é diferente de remover uma variável global — ao trabalhar com ambientes personalizados, é necessário especificar o ambiente explicitamente.

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 extrair um ambiente

as.list(e) converte todos os vínculos de um ambiente em uma lista nomeada, facilitando a inspeção ou a serialização do conteúdo. O resultado é uma imagem estática — alterações posteriores no ambiente não são refletidas na 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)

Ambientes como tabelas hash

A opção hash = TRUE de new.env() (padrão quando o pai é definido) habilita a busca baseada em hash, tornando a busca por nomes O(1). Isso faz com que ambientes grandes sejam muito mais rápidos do que listas para armazenar pares chave-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 vs. compartilhar ambientes

Atribuir um ambiente a uma nova variável não o copia — ambas as variáveis fazem referência ao mesmo objeto. Use as.list() e depois list2env() para criar uma cópia verdadeira, caso precise de ambientes independentes.

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

Verificação rápida

Qual função verifica se um nome está vinculado a um ambiente sem pesquisar os ambientes pai?

Criação de ambientes: principais conclusões

Principais conclusões sobre a criação e a inspeção de ambientes:

  • new.env(parent=e) cria um ambiente vazio; hash=TRUE para armazenamentos grandes
  • assign('x', v, envir=e) e get('x', envir=e) para acesso programático
  • e$x e e[['x']] funcionam como acessadores de listas
  • ls(envir=e) lista os nomes; exists('x', envir=e, inherits=FALSE) para uma verificação estrita
  • as.list(e) converte o ambiente em uma lista; list2env() o reconstrói
  • Ambientes são objetos de referência — a atribuição os compartilha, não os 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')

Perguntas Frequentes

A aula “Criando e inspecionando ambientes” é grátis?

Sim — o texto completo de “Criando e inspecionando ambientes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Criando e inspecionando ambientes”?

Use new.env(), environment(), ls() e get() para trabalhar com ambientes. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Criando e inspecionando ambientes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O que é um ambiente em R?
  2. Regras de escopo léxico
  3. Escopo global versus local
  4. Criando e inspecionando ambientes
← Voltar para R Academy