Variabili e Assegnazione in R

Le variabili sono uno dei concetti fondamentali nella programmazione in R. Rappresentano contenitori per memorizzare dati di qualsiasi tipo, dai numeri ai dataframe complessi. In questa guida esploreremo i diversi operatori di assegnazione, le regole di denominazione e le funzioni per gestire le variabili.

Operatori di Assegnazione

R offre diversi operatori di assegnazione, ciascuno con un comportamento specifico. Conoscere le differenze tra questi operatori e’ essenziale per scrivere codice corretto.

Operatore <- (Freccia Sinistra)

L’operatore <- e’ il metodo di assegnazione standard e consigliato in R. Assegna il valore alla destra alla variabile a sinistra.

nome <- "Luca"
eta <- 28
altezza <- 1.75

print(nome)    # [1] "Luca"
print(eta)     # [1] 28
print(altezza) # [1] 1.75

Operatore = (Uguale)

L’operatore = funziona in modo simile a <- per l’assegnazione a livello di ambiente globale, ma ha un comportamento diverso all’interno delle chiamate a funzione.

# Assegnazione nell'ambiente globale
citta = "Milano"
print(citta) # [1] "Milano"

# Dentro una funzione, = assegna ai parametri
risultato <- mean(x = c(10, 20, 30))
# La variabile x NON viene creata nell'ambiente
print(risultato) # [1] 20

Operatore -> (Freccia Destra)

L’operatore -> assegna il valore a sinistra alla variabile a destra. E’ meno comune ma utile in alcune situazioni, ad esempio alla fine di una catena di operazioni.

"Ingegnere" -> professione
100 * 2 -> risultato

print(professione) # [1] "Ingegnere"
print(risultato)   # [1] 200

Operatore <<- (Assegnazione Globale)

L’operatore <<- viene utilizzato per assegnare un valore a una variabile nell’ambiente genitore o globale, anziche’ nell’ambiente locale. Questo e’ particolarmente utile all’interno di funzioni quando si desidera modificare una variabile definita all’esterno.

contatore <- 0

incrementa <- function() {
  contatore <<- contatore + 1  # Modifica la variabile globale
}

incrementa()
incrementa()
incrementa()
print(contatore) # [1] 3

Senza <<-, la modifica rimarrebbe confinata all’interno della funzione e la variabile globale non verrebbe alterata.

contatore <- 0

incrementa_locale <- function() {
  contatore <- contatore + 1  # Modifica solo la copia locale
  cat("Valore locale:", contatore, "\n")
}

incrementa_locale() # Valore locale: 1
print(contatore)    # [1] 0  (il valore globale non cambia)

Regole per i Nomi delle Variabili

Le variabili in R devono rispettare regole precise per i loro nomi:

# Nomi validi
valore_massimo <- 100
valoreMassimo <- 100
valore.massimo <- 100
.nascosta <- "non visibile con ls()"
x2 <- 42

# Nomi NON validi
# 2x <- 10         # Non puo' iniziare con un numero
# valore-max <- 10 # Il trattino non e' consentito
# my var <- 10     # Gli spazi non sono ammessi
# TRUE <- 5        # Parola riservata

Le convenzioni di stile piu’ diffuse in R sono:

• snake_case: nome_utente, valore_massimo (raccomandato dalla guida di stile Tidyverse)
• Punto come separatore: nome.utente, valore.massimo (tradizionale in R)
• camelCase: nomeUtente, valoreMassimo (meno comune)

Variabili Globali vs Locali

In R, lo scope delle variabili e’ determinato dall’ambiente in cui sono definite.

# Variabile globale
messaggio_globale <- "Sono globale"

modifica_scope <- function() {
  # Variabile locale alla funzione
  messaggio_locale <- "Sono locale"

  # Accesso alla variabile globale (lettura)
  cat("Dentro la funzione:", messaggio_globale, "\n")
  cat("Variabile locale:", messaggio_locale, "\n")
}

modifica_scope()
# Dentro la funzione: Sono globale
# Variabile locale: Sono locale

print(messaggio_globale) # [1] "Sono globale"
# print(messaggio_locale)  # Errore: oggetto 'messaggio_locale' non trovato

Le variabili locali esistono solo all’interno della funzione in cui sono definite e vengono distrutte quando la funzione termina l’esecuzione.

Elencare le Variabili con ls()

La funzione ls() restituisce un vettore con i nomi di tutti gli oggetti presenti nell’ambiente corrente. E’ molto utile per avere una panoramica delle variabili definite.

x <- 10
y <- 20
nome <- "Mario"
dati <- c(1, 2, 3)

# Elencare tutte le variabili
ls()
# [1] "dati" "nome" "x"    "y"

# Filtrare le variabili con un pattern
ls(pattern = "^d")
# [1] "dati"

# Mostrare anche le variabili nascoste (che iniziano con .)
.valore_segreto <- 99
ls(all.names = TRUE)
# [1] ".valore_segreto" "dati" "nome" "x" "y"

Rimuovere Variabili con rm()

La funzione rm() (abbreviazione di “remove”) consente di eliminare variabili dall’ambiente, liberando la memoria occupata.

a <- 10
b <- 20
c <- 30

# Rimuovere una singola variabile
rm(a)
# print(a) # Errore: oggetto 'a' non trovato

# Rimuovere piu' variabili contemporaneamente
rm(b, c)

# Rimuovere TUTTE le variabili dall'ambiente
rm(list = ls())

ls() # character(0) - nessuna variabile presente

Utilizzare rm(list = ls()) e’ utile per pulire l’ambiente all’inizio di un nuovo script di analisi, garantendo che non ci siano variabili residue da esecuzioni precedenti.

Verificare il Tipo con class()

La funzione class() restituisce il tipo (classe) di una variabile. In R, ogni valore ha una classe che ne determina il comportamento.

numero <- 42
intero <- 42L
testo <- "Ciao mondo"
logico <- TRUE
vettore <- c(1, 2, 3)
lista <- list(a = 1, b = "due")

cat("Tipo di numero:", class(numero), "\n")   # numeric
cat("Tipo di intero:", class(intero), "\n")   # integer
cat("Tipo di testo:", class(testo), "\n")     # character
cat("Tipo di logico:", class(logico), "\n")   # logical
cat("Tipo di vettore:", class(vettore), "\n") # numeric
cat("Tipo di lista:", class(lista), "\n")     # list

Oltre a class(), R offre anche typeof() per ottenere il tipo interno e str() per una panoramica compatta della struttura di un oggetto.

x <- 42
cat("class:", class(x), "\n")   # numeric
cat("typeof:", typeof(x), "\n") # double

str(list(a = 1, b = "testo", c = TRUE))
# List of 3
#  $ a: num 1
#  $ b: chr "testo"
#  $ c: logi TRUE

Conclusioni

Le variabili in R offrono grande flessibilita’ grazie ai diversi operatori di assegnazione disponibili. L’operatore <- rimane il metodo consigliato per la maggior parte delle situazioni, mentre <<- e’ riservato ai casi in cui si necessita di modificare variabili in ambienti superiori. Le funzioni ls(), rm() e class() sono strumenti indispensabili per gestire e ispezionare le variabili durante l’analisi dei dati.