0Pricing
R Academy · Lezione

Che cos'è un environment in R?

Esplori gli environment come liste denominate con riferimenti agli environment genitori.

Che cos'è un environment in R? è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cos'è un environment?

In R, un environment è una raccolta di associazioni con nome, simile a una lista con nome, più un puntatore a un parent environment. Ogni variabile risiede in un environment. Quando R cerca un nome, esamina prima l'environment corrente, poi risale la catena degli environment genitori.

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

R dispone di diversi environment integrati: globalenv() è lo spazio di lavoro interattivo, baseenv() contiene le funzioni di base di R ed emptyenv() è il vertice della catena, senza un genitore. Ogni catena di environment termina infine in 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 catena degli environment

Ogni environment ha esattamente un genitore, ad eccezione di emptyenv(). Quando R non trova un nome nell'environment corrente, passa al genitore, poi al genitore del genitore e così via. Questa catena è il meccanismo con cui R risolve i nomi delle variabili.

# 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() per una funzione

Ogni funzione ha un environment associato, ovvero quello in cui è stata creata. environment(f) restituisce tale environment. Questo è l'enclosing environment della funzione e determina dove vengono cercate le variabili libere.

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() su un environment

as.list(env) converte le associazioni di un environment in una lista con nome, utile per esaminarne programmaticamente i contenuti. Combinandolo con globalenv() è possibile visualizzare tutte le variabili della sessione corrente.

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() — Elencare i contenuti di un environment

ls() elenca i nomi associati in un environment. Per impostazione predefinita mostra l'environment globale. Passi envir = e per esaminare un environment specifico. Aggiunga all.names = TRUE per includere i nomi che iniziano con ..

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() — Creazione degli ambienti

new.env(parent = e) crea un nuovo ambiente vuoto con il genitore specificato. Utilizzi emptyenv() come genitore quando desidera un ambiente completamente isolato, senza associazioni ereditate.

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

Ambienti e liste a confronto

Gli ambienti sembrano liste con nomi, ma si comportano diversamente: vengono sempre modificati sul posto (senza copia alla modifica), hanno un genitore e la ricerca dei nomi viene eseguita tramite una tabella hash (quindi è veloce). Le liste vengono copiate quando vengono modificate, gli ambienti 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() e get() in un ambiente

exists('name', envir = e) verifica se un nome è associato a un ambiente (o, per impostazione predefinita, a uno dei suoi genitori). get('name', envir = e) recupera il valore. Entrambe accettano inherits = FALSE per cercare solo nell'ambiente specificato.

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() per gli ambienti integrati

environmentName(env) restituisce il nome leggibile degli ambienti speciali. Gli ambienti creati dall'utente restituiscono '' (stringa vuota). Questo aiuta a tracciare dove sono state definite le variabili durante il debugging.

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

Esercitazione: utilizzo degli ambienti come cache

Poiché gli ambienti vengono modificati sul posto, funzionano bene come cache mutabili o mappe hash. Memorizzi i risultati calcolati in un ambiente per evitare di ricalcolarli: è più veloce che modificare una lista (che viene copiata).

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 rapida

Qual è l'ambiente più in alto nella catena degli ambienti di R, cioè quello senza genitore?

Ambienti: concetti chiave

Concetti chiave sugli ambienti di R:

  • Un ambiente = associazioni con nome + puntatore al genitore
  • globalenv() = il proprio spazio di lavoro; baseenv() = R di base; emptyenv() = termine della catena
  • La ricerca dei nomi risale la catena dei genitori finché trova il nome o raggiunge emptyenv()
  • ls(envir=e) elenca le associazioni; exists() verifica; get() recupera
  • Gli ambienti sono oggetti referenziati: non vengono copiati alla modifica
  • new.env(parent=emptyenv()) crea un ambiente isolato
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')

Domande Frequenti

La lezione «Che cos'è un environment in R?» è gratuita?

Sì — il testo completo di «Che cos'è un environment in R?» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Che cos'è un environment in R?»?

Esplori gli environment come liste denominate con riferimenti agli environment genitori. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Che cos'è un environment in R?»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Che cos'è un environment in R?
  2. Regole dello scoping lessicale
  3. Scope globale e locale
  4. Creazione e analisi degli environment
← Torna a R Academy