R Academy · Aula

O que é um ambiente em R?

Explore ambientes como listas nomeadas com referências para ambientes-pai.

Aula 1 de 413 etapas

O que é um ambiente em R? é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 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.

O que é um ambiente

Em R, um ambiente é uma coleção de associações nomeadas (como uma lista nomeada) mais um ponteiro para um ambiente pai. Toda variável vive em algum ambiente. Quando R procura um nome, primeiro pesquisa o ambiente atual e depois percorre a cadeia de ambientes pais.

# 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() e emptyenv()

R tem vários ambientes integrados: globalenv() é o seu espaço de trabalho interativo, baseenv() contém as funções básicas de R e emptyenv() é o topo da cadeia, sem ambiente pai. Toda cadeia de ambientes termina, por fim, em 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')

A cadeia de ambientes

Cada ambiente tem exatamente um pai, exceto emptyenv(). Quando R não encontra um nome no ambiente atual, passa ao pai, depois ao pai do pai e assim por diante. É assim que R resolve os nomes das variáveis.

# 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 uma função

Toda função tem um ambiente associado: aquele em que foi criada. environment(f) retorna esse ambiente. Esse é o ambiente de definição da função e determina onde ela procura variáveis livres.

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

as.list(env) converte as associações de um ambiente em uma lista nomeada, o que é útil para inspecionar seu conteúdo programaticamente. Combiná-lo com globalenv() mostra todas as variáveis atuais da sessão.

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() — Listando o conteúdo de um ambiente

ls() lista os nomes associados em um ambiente. Por padrão, mostra o ambiente global. Passe envir = e para inspecionar um ambiente específico. Adicione all.names = TRUE para incluir nomes que começam com ..

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() — Criando ambientes

new.env(parent = e) cria um ambiente vazio com o pai fornecido. Use emptyenv() como pai quando quiser um ambiente completamente isolado, sem vínculos herdados.

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

Ambientes versus listas

Os ambientes se parecem com listas nomeadas, mas se comportam de maneira diferente: são sempre modificados no próprio lugar (sem cópia na modificação), têm um pai e a busca por nomes é feita por tabela hash (de forma rápida). As listas são copiadas quando modificadas; os ambientes, não.

# 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() e get() em um ambiente

exists('name', envir = e) verifica se um nome está associado a um ambiente (ou aos pais dele, por padrão). get('name', envir = e) recupera o valor. Ambos aceitam inherits = FALSE para pesquisar apenas no ambiente 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 ambientes integrados

environmentName(env) retorna o nome legível de ambientes especiais. Ambientes criados pelo usuário retornam '' (cadeia de caracteres vazia). Isso ajuda a rastrear onde as variáveis foram definidas durante a depuração.

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ática: usando ambientes como caches

Como os ambientes são modificados no próprio lugar, eles funcionam bem como caches mutáveis ou mapas hash. Armazene resultados calculados em um ambiente para evitar recalculá-los — isso é mais rápido do que modificar uma lista (que é copiada).

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

Verificação rápida

Qual é o ambiente mais acima na cadeia de ambientes do R — aquele que não tem pai?

Responda na aula interativa

Ambientes: principais conclusões

Principais conclusões sobre ambientes do R:

Um ambiente = vínculos nomeados + ponteiro para o pai
globalenv() = seu espaço de trabalho; baseenv() = R básico; emptyenv() = término da cadeia
A busca por nomes percorre a cadeia de pais até encontrar o nome ou chegar a emptyenv()
ls(envir=e) lista os vínculos; exists() verifica; get() recupera
Os ambientes são objetos por referência — não há cópia na modificação
new.env(parent=emptyenv()) cria um ambiente isolado

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

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “O que é um ambiente em R?” é grátis?

Sim — o texto completo de “O que é um ambiente em R?” é 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 “O que é um ambiente em R?”?

Explore ambientes como listas nomeadas com referências para ambientes-pai. 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 1 de 4.

Quanto tempo leva a aula “O que é um ambiente em R?”?

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

← Voltar para R Academy