Come eseguire uno script R: Rscript, source() e RStudio

Due modi di usare R: console e script

R ha una console interattiva (una REPL: leggi, valuta, stampa, ripeti): scrivi un'espressione e R risponde subito. Scrivendo R in un terminale, o guardando il pannello in basso di RStudio, ottieni un prompt > in cui ogni riga viene eseguita nel momento in cui premi Invio. La console è il posto dove esplori: curiosi tra i dati, provi una riga, guardi il risultato.

Uno script R è semplicemente un file di testo con codice R, salvato con estensione .R. Gli script sono il posto dove l'analisi vive: una ricetta riproducibile che chiunque (compreso il te stesso del futuro) può eseguire dall'inizio alla fine ottenendo lo stesso risultato.

Uno script non ha niente di esotico. Questo è uno script completo, eseguilo:

# summary.R - a complete R script
temperatures <- c(21.5, 23.1, 19.8, 24.6, 22.3)

avg <- mean(temperatures)
cat("Readings:", length(temperatures), "\n")
cat("Average temperature:", avg, "\n")
cat("Warmest:", max(temperatures), "\n")

Tutto quello che segue riguarda i diversi modi di dare in pasto a R un file come questo.

Rscript: eseguire un file dalla riga di comando

R installa uno strumento da riga di comando chiamato Rscript, fatto proprio per questo. In un terminale, nella cartella che contiene il tuo file:

Rscript summary.R

R si avvia, esegue il file dall'inizio alla fine, stampa quello che lo script stampa ed esce. È lo strumento principale per l'automazione: cron job, pipeline di dati, server, CI, ovunque il codice giri senza una persona che guarda.

C'è un comportamento che prima o poi sorprende tutti: nella console, scrivere un'espressione nuda come avg ne stampa automaticamente il valore. Con Rscript, un'espressione nuda dentro una funzione o un ciclo può non stampare nulla, ed è per questo che gli script dicono quello che intendono con chiamate esplicite a cat() o print(). Prendi subito questa abitudine.

source(): eseguire un file dall'interno di R

Sei già in una sessione R e vuoi eseguire un file? Serve source():

source("summary.R")

Ogni riga del file viene eseguita nella tua sessione corrente, e tutto quello che lo script definisce, variabili e funzioni, resta disponibile dopo. Il punto è proprio questo: source() è il modo per caricare le tue funzioni di supporto in una sessione interattiva.

Di default source() lavora in silenzio, a parte l'output esplicito. Per vederlo all'opera, fai stampare ogni riga mentre viene eseguita:

source("summary.R", echo = TRUE)

Nota il percorso relativo: "summary.R" significa "nella directory di lavoro corrente", e dove si trovi dipende da come hai avviato R. Quando source() o read.csv() misteriosamente non trovano un file che è proprio lì, la colpa è quasi sempre della directory di lavoro: vedi directory di lavoro.

Eseguire script in RStudio

RStudio ti offre entrambe le modalità con due comandi, e vale la pena interiorizzare la differenza:

• Run (Ctrl+Invio, Cmd+Invio su macOS): esegue nella console la riga corrente o la selezione evidenziata. È la marcia dell'esplorazione: scrivi una riga, eseguila, guarda, correggi.
• Source (il pulsante Source, o Ctrl/Cmd+Shift+S): esegue l'intero file, esattamente come source() nella console.

Il tranello dell'esecuzione riga per riga è che la sessione della console accumula stato: le variabili create da righe che poi hai modificato o cancellato sono ancora vive, quindi lo script "funziona" per te e fallisce per tutti gli altri. La prova onesta di uno script è Source in una sessione nuova (Session → Restart R, poi Source). Se la supera, è riproducibile.

Rendere eseguibile uno script (macOS / Linux)

Sui sistemi di tipo Unix puoi trasformare uno script R in un comando vero e proprio. Metti una riga shebang in cima al file:

#!/usr/bin/env Rscript
cat("I am a self-running R script\n")

Poi rendilo eseguibile una volta sola ed eseguilo direttamente:

chmod +x summary.R
./summary.R

Lo shebang dice alla shell quale interprete deve eseguire il file; env Rscript trova Rscript ovunque si trovi nel PATH di quella macchina. Dato che la riga inizia con #, R stesso la legge come un commento e la ignora.

Passare argomenti a uno script

Gli script reali ricevono degli input, come un nome di file, una data o una soglia, passati dopo il nome dello script:

Rscript report.R sales.csv 2026

Dentro lo script, commandArgs(trailingOnly = TRUE) restituisce i tuoi argomenti come vettore di caratteri (trailingOnly = TRUE scarta gli argomenti interni dell'interprete, e lo vorrai praticamente sempre):

# report.R
args <- commandArgs(trailingOnly = TRUE)

input_file <- args[1]
year <- as.numeric(args[2])

cat("Reading:", input_file, "\n")
cat("Filtering to year:", year, "\n")

Tutto arriva come testo, "2026" e non 2026, quindi converti con as.numeric() prima di fare calcoli. Possiamo simulare la logica di lettura in una forma eseguibile:

# Pretend these came from the command line
args <- c("sales.csv", "2026")

input_file <- args[1]
year <- as.numeric(args[2])

cat("Reading:", input_file, "\n")
cat("Next year will be:", year + 1, "\n")

Quale usare?

• Esplorare i dati, provare idee → la console, o Run in RStudio.
• Eseguire tutta l'analisi → Source in RStudio, o Rscript in un terminale.
• Caricare le tue funzioni di supporto in una sessione → source("helpers.R").
• Automazione, pianificatori, pipeline → Rscript, con commandArgs() per gli input.

La sintassi di quello che va dentro questi file è la prossima lezione: vedi sintassi di R.

Cosa ti porti a casa

• La console serve per esplorare; i file di script .R servono per un'analisi riproducibile.
• Rscript file.R esegue uno script dalla riga di comando; source("file.R") lo esegue dentro una sessione (aggiungi echo = TRUE per vederlo all'opera).
• In RStudio, Run esegue una riga e Source esegue il file, e Source in una sessione nuova è la vera prova di riproducibilità.
• #!/usr/bin/env Rscript + chmod +x rende uno script eseguibile direttamente; commandArgs(trailingOnly = TRUE) ne legge gli argomenti come testo.

Prossimo passo: la sintassi di R, cioè l'assegnazione con <-, le chiamate di funzione e la regola per cui tutto è un vettore.