0Pricing
R Academy · Lezione

Creazione e analisi degli environment

Usi new.env(), environment(), ls() e get() per lavorare con gli environment.

Creazione e analisi degli environment è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Creazione di un nuovo ambiente

new.env(parent = e) crea un nuovo ambiente vuoto. L'argomento parent specifica quale ambiente cercare quando un nome non viene trovato in quello nuovo. Utilizzi emptyenv() per un ambiente completamente isolato.

# 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() — Aggiunta di associazioni

assign('name', value, envir = e) crea o aggiorna un'associazione con nome nell'ambiente specificato. È l'equivalente programmatico di e$name <- value, ma funziona quando il nome è memorizzato in una variabile.

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 una singola associazione. mget(c('a','b'), envir = e) recupera più associazioni contemporaneamente e restituisce una lista con nomi. Entrambe generano un errore se il nome non esiste (a meno che inherits non consenta di cercare lungo la catena).

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() — Elenco delle associazioni

ls(envir = e) restituisce un vettore di caratteri contenente tutti i nomi associati nell'ambiente e. Aggiunga all.names = TRUE per includere i nomi che iniziano con . (nascosti per impostazione predefinita). I nomi vengono restituiti in ordine alfabetico.

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) verifica solo l'ambiente specificato, non i suoi genitori. Con inherits = TRUE (impostazione predefinita), cerca anche lungo la catena dei genitori. Utilizzi inherits = FALSE per verifiche locali rigorose.

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) restituisce il nome di un ambiente integrato ('R_GlobalEnv', 'package:base', ecc.). Gli ambienti creati dall'utente restituiscono ''. parent.env(e) restituisce l'oggetto ambiente genitore.

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

Sintassi $ per gli ambienti

Gli ambienti supportano la sintassi $ e [[, come le liste, per leggere e scrivere le associazioni. Spesso è più comoda di get()/assign() per l'accesso diretto quando il nome è noto al momento della scrittura.

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() in un ambiente specifico

rm('name', envir = e) rimuove un'associazione da un ambiente specifico. È diverso dal rimuovere una variabile globale: quando lavora con ambienti personalizzati, deve specificare esplicitamente l'ambiente.

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() per convertire un ambiente

as.list(e) converte tutte le associazioni di un ambiente in una lista con nomi, rendendo semplice esaminarne o serializzarne il contenuto. Il risultato è un'istantanea: le modifiche successive all'ambiente non vengono riflesse nella 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)

Gli ambienti come tabelle hash

L'opzione hash = TRUE di new.env() (predefinita quando è impostato il genitore) abilita la ricerca basata su hash, rendendo la ricerca dei nomi O(1). Per memorizzare coppie chiave-valore, questo rende gli ambienti di grandi dimensioni molto più veloci delle liste.

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

Copiare o condividere gli ambienti

Assegnare un ambiente a una nuova variabile non lo copia: entrambe le variabili fanno riferimento allo stesso oggetto. Usi as.list() e poi list2env() per creare una copia reale, se ha bisogno di ambienti indipendenti.

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 rapida

Quale funzione verifica se un nome è associato a un ambiente senza cercare negli ambienti genitori?

Creazione degli ambienti: concetti chiave

Concetti chiave per creare e ispezionare gli ambienti:

  • new.env(parent=e) crea un nuovo ambiente vuoto; hash=TRUE per insiemi di grandi dimensioni
  • assign('x', v, envir=e) e get('x', envir=e) per l'accesso programmatico
  • e$x e e[['x']] funzionano come gli accessor delle liste
  • ls(envir=e) elenca i nomi; exists('x', envir=e, inherits=FALSE) per un controllo rigoroso
  • as.list(e) converte in una lista; list2env() ricostruisce l'ambiente
  • Gli ambienti sono oggetti referenziati: l'assegnazione li condivide, non li 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')

Domande Frequenti

La lezione «Creazione e analisi degli environment» è gratuita?

Sì — il testo completo di «Creazione e analisi degli environment» è 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 «Creazione e analisi degli environment»?

Usi new.env(), environment(), ls() e get() per lavorare con gli environment. 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 4 di 4.

Quanto tempo richiede la lezione «Creazione e analisi degli environment»?

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