Escopo global versus local
Diferencie .GlobalEnv, ambientes de funções e closures.
Escopo global versus local é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 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.
Variáveis locais em funções
As variáveis atribuídas com <- ou = dentro do corpo de uma função são locais a essa função. Elas são criadas no próprio ambiente da função e desaparecem quando a função retorna. Nunca afetam o escopo de chamada.
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'Os parâmetros de funções são locais
Os parâmetros de funções também são variáveis locais. Modificar um parâmetro dentro da função não afeta o argumento no ambiente de chamada. O R passa argumentos por valor (com semântica de cópia na modificação).
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 atribuição global
<<- (superatribuição) procura na cadeia de pais e atribui ao primeiro vínculo correspondente encontrado. Se não houver correspondência em nenhum lugar, cria o vínculo no ambiente global. Use-o com moderação — o uso excessivo de <<- torna as funções difíceis de compreender.
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')<<- pesquisa a cadeia para cima
<<- não atribui cegamente ao ambiente global — ele percorre a cadeia de pais e atribui ao primeiro ambiente onde o nome já existe. Se a variável existir em uma função envolvente, é nesse ambiente que ela será atualizada.
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 direcionar explicitamente o ambiente
assign('name', value, envir = e) atribui diretamente a um ambiente específico. É mais explícito do que <<- e é útil quando você tem um objeto de ambiente e quer definir um valor nele com precisão.
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() — blocos de código isolados
local({...}) avalia uma expressão em um ambiente local novo. As variáveis criadas dentro do bloco não vazam para o ambiente global. Isso é útil para cálculos temporários que não devem poluir o espaço de trabalho.
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() versus função para isolamento
Tanto local() quanto uma função chamada imediatamente fornecem isolamento de escopo. local() é mais conciso para um isolamento pontual; uma função nomeada é melhor quando você quer que a lógica seja reutilizável ou possa ser testada.
# 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')Lendo variáveis globais a partir de uma função
As funções podem ler variáveis de seu escopo envolvente (global ou não) sem nenhuma sintaxe especial. Isso é o escopo léxico padrão. No entanto, depender muito do estado global torna as funções mais difíceis de testar — prefira argumentos explícitos sempre que possível.
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')Ocultação de variáveis
Quando uma variável local tem o mesmo nome que uma variável global, o vínculo local oculta o global. Dentro da função, usa-se a versão local. A variável global permanece intacta. Isso pode causar erros sutis quando ocorre sem intenção.
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 shadowAmbientes de function()
Cada vez que uma função é chamada, o R cria um novo ambiente para essa chamada, tendo como pai o ambiente envolvente da função. As variáveis locais de chamadas diferentes não interferem umas nas outras, nem mesmo em chamadas 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 remover variáveis
rm('name') ou rm(name) remove um vínculo do ambiente atual (ou especificado). Use-o para limpar variáveis temporárias. Passe envir = e para remover uma variável de um ambiente específico.
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')Verificação rápida
O que <<- faz que a atribuição regular <- não faz?
Escopo: principais conclusões
Principais conclusões sobre escopo global e local:
<-dentro de uma função cria uma variável local — a global não é alterada- Os parâmetros de funções são locais; o R passa por valor (cópia na modificação)
<<-percorre a cadeia de pais e modifica o primeiro vínculo correspondenteassign('x', val, envir=e)faz uma atribuição direcionada explicitamente a um ambientelocal({...})fornece um escopo descartável sem criar uma função nomeada- Evite ocultar nomes 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')Perguntas Frequentes
A aula “Escopo global versus local” é grátis?
Sim — o texto completo de “Escopo global versus local” é 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 “Escopo global versus local”?
Diferencie .GlobalEnv, ambientes de funções e closures. 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 3 de 4.
Quanto tempo leva a aula “Escopo global versus local”?
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
- O que é um ambiente em R?
- Regras de escopo léxico
- Escopo global versus local
- Criando e inspecionando ambientes