0Pricing
R Academy · Lezione

Progetti R e gestione dell'area di lavoro

Crei progetti RStudio e gestisca .RData, .Rhistory e .Renviron.

Progetti R e gestione dell'area di lavoro è 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.

L'ambiente di lavoro R: .RData e .Rhistory

Per impostazione predefinita, quando si esce da R viene richiesto di salvare l'workspace — tutti gli oggetti in memoria — in un file nascosto chiamato .RData nella directory di lavoro. La cronologia dei comandi viene salvata in .Rhistory. Questi file vengono caricati automaticamente nella sessione successiva.

Questa comodità può però compromettere la riproducibilità.

# .RData: binary snapshot of all objects in the global environment
# .Rhistory: text file of every command you typed

# See what would be saved right now:
cat('Objects that would be saved:', length(ls()), '\n')
cat('Their names:', paste(ls(), collapse = ', '))

# Workspace saving is controlled by:
# Tools -> Global Options -> General -> Save workspace (NEVER recommended)
# Or at startup: R --no-save --no-restore

Perché evitare il salvataggio automatico di .RData?

Affidarsi a .RData significa che i risultati non possono essere riprodotti da zero. Gli oggetti si accumulano invisibilmente tra le sessioni, le vecchie variabili possono entrare in conflitto con quelle nuove e i collaboratori non possono replicare il vostro ambiente. La soluzione è non salvare mai il workspace e ricrearlo sempre eseguendo gli script.

# The recommended R startup setting (in RStudio):
# Tools -> Global Options -> General
#   Restore .RData at startup: UNCHECKED
#   Save workspace on exit: NEVER

# This forces you to write scripts that are fully self-contained.
# A fresh session that runs cleanly = reproducible analysis.

# Equivalent command-line flags:
# R --no-save --no-restore

cat('Always start fresh!')

rm() — Pulire il workspace

rm(list = ls()) è il modo canonico per rimuovere tutti gli oggetti dall'ambiente globale, simulando una sessione nuova senza riavviare R. Viene spesso inserito all'inizio di uno script per garantire un ambiente pulito a ogni esecuzione.

# Create some objects
a <- 1
b <- 'hello'
df <- data.frame(x = 1:3)

cat('Before rm:', length(ls()), 'objects\n')

# Remove specific objects
rm(a, b)
cat('After rm(a,b):', length(ls()), 'objects\n')

# Remove ALL objects in global environment
rm(list = ls())
cat('After rm(list=ls()):', length(ls()), 'objects')

options() — Impostazioni globali della sessione

options() controlla numerosi comportamenti dell'intera sessione R. Due delle opzioni impostate più frequentemente sono scipen (penalità per la notazione scientifica) e digits (numero di cifre significative stampate). Impostatele all'inizio degli script per ottenere un output coerente.

# Default behavior:
cat(0.000123456, '\n')    # may show 1.23456e-04

# Suppress scientific notation (positive scipen = prefer fixed)
options(scipen = 999)
cat(0.000123456, '\n')    # now shows 0.000123456

# Control printed digits
options(digits = 4)
cat(pi, '\n')              # 3.142

# Check current options:
cat('scipen:', getOption('scipen'), '\n')
cat('digits:', getOption('digits'))

.Renviron — Variabili d'ambiente

Il file .Renviron memorizza le variabili d'ambiente che R carica all'avvio. È il posto giusto per segreti e valori di configurazione come chiavi API, password di database e percorsi del file system, mantenendoli fuori dal codice sorgente.

# .Renviron file (in ~ or project root):
# DATABASE_URL=postgres://user:pass@host/db
# OPENAI_API_KEY=sk-abc123
# DATA_ROOT=/data/shared

# Read in R:
db_url <- Sys.getenv('DATABASE_URL')
api_key <- Sys.getenv('OPENAI_API_KEY', unset = 'KEY_NOT_SET')

cat('DB URL set:', nchar(db_url) > 0, '\n')
cat('API key:', api_key)

# To edit .Renviron:
# usethis::edit_r_environ()   <- if usethis is installed
# file.edit('~/.Renviron')    <- base R

saveRDS() — Salvare un singolo oggetto

saveRDS() serializza un singolo oggetto R in un file .rds. È il metodo preferito per memorizzare nella cache i risultati di calcoli costosi, perché il file contiene esattamente un oggetto e consente di controllare con precisione cosa salvare e caricare.

# Create an object to save
result_list <- list(
  model   = 'linear_regression',
  r2      = 0.87,
  rmse    = 12.4,
  created = Sys.time()
)

# Save to disk
tmp_rds <- tempfile(fileext = '.rds')
saveRDS(result_list, file = tmp_rds)
cat('Saved to:', tmp_rds, '\n')

# Load it back (even in a fresh session)
loaded <- readRDS(tmp_rds)
cat('R-squared:', loaded$r2)

readRDS() — Ripristinare un singolo oggetto

readRDS() deserializza un file .rds trasformandolo nuovamente in un oggetto R. A differenza di load(), il valore restituito deve essere assegnato a un nome: potete quindi caricare lo stesso file con nomi diversi in parti diverse del codice.

# Suppose model_results.rds was saved earlier
tmp <- tempfile(fileext = '.rds')
saveRDS(list(coef = c(1.2, 3.4), n = 100), tmp)

# Load with a meaningful name:
model_output <- readRDS(tmp)
cat('Coefficients:', model_output$coef, '\n')
cat('Sample size:', model_output$n, '\n')

# Key advantage over load():
# With load(), the name is baked into the file.
# With readRDS(), YOU choose the name on load.
cat('readRDS gives you naming control')

save() e load() — Più oggetti

save() serializza uno o più oggetti denominati in un file .RData. load() li ripristina, ma i nomi originali vengono ripristinati automaticamente e possono quindi sovrascrivere silenziosamente oggetti esistenti. Usatele con cautela.

# Save multiple objects at once
scores <- c(85, 92, 78)
labels <- c('Alice', 'Bob', 'Carol')

tmp_rdata <- tempfile(fileext = '.RData')
save(scores, labels, file = tmp_rdata)
cat('Saved to:', tmp_rdata, '\n')

# Remove originals to simulate a new session
rm(scores, labels)
cat('Removed. Objects now:', length(ls()), '\n')

# Load restores original names automatically
load(tmp_rdata)
cat('Restored scores:', scores)

saveRDS e save — Quando usare l'una o l'altra

Usate saveRDS() per i singoli oggetti quando volete avere il pieno controllo dei nomi al caricamento: è ideale per gli output dei modelli, i dataset elaborati e i risultati memorizzati nella cache. Usate save() solo quando dovete raggruppare più oggetti denominati per uno specifico flusso di lavoro con un collaboratore.

# saveRDS: one object, you name it on load
# saveRDS(my_model, 'outputs/model_v2.rds')
# m <- readRDS('outputs/model_v2.rds')  <- your name choice

# save: multiple objects, names fixed in the file
# save(model, validation_df, file = 'outputs/session.RData')
# load('outputs/session.RData')  <- restores 'model' and 'validation_df'

# Practical rule:
# saveRDS for caching single results
# save for snapshots shared between collaborators

cat('saveRDS is usually the better choice')

Controllare e ripristinare options()

Le opzioni impostate durante una sessione rimangono valide solo per quella sessione. Per rendere lo script autonomo, impostate all'inizio le opzioni necessarie e, facoltativamente, ripristinate i valori precedenti al termine dello script usando on.exit().

# Capture current options before changing
old_options <- options(scipen = 999, digits = 3)

# Use on.exit to restore them no matter what
on.exit(options(old_options), add = TRUE)

# Now do your work
cat(pi, '\n')           # 3.14
cat(1234567.89, '\n')   # 1234568 (no sci notation)

# When function or script exits, options are restored automatically
cat('Options will restore on exit')

Progetti RStudio per la gestione del workspace

Un progetto RStudio (file .Rproj) imposta automaticamente la directory di lavoro sulla radice del progetto, mantiene un .Rhistory separato per ogni progetto e isola le opzioni della sessione. È il metodo standard per gestire progetti R autonomi.

# When you open a .Rproj file, RStudio automatically:
# 1. Sets working directory to the project root
# 2. Loads the project-specific .Rhistory
# 3. Optionally restores project .RData

# Best practice for new projects:
# File -> New Project -> New Directory -> New Project

# Your project structure then looks like:
# my_project/
#   my_project.Rproj
#   .Rprofile        (project-level options)
#   .Renviron        (project-level env vars)
#   R/               (scripts)
#   data/            (raw data)
#   output/          (results)

cat('RStudio Projects = clean workspaces')

Verifica rapida

Volete salvare su disco un singolo data frame R chiamato clean_data, per poterlo ricaricare in un altro script con qualsiasi nome di variabile scegliate. Quale funzione dovreste usare?

Gestione del workspace — concetti chiave

Un workspace R ben gestito è il fondamento di un'analisi riproducibile:

  • .RData / .Rhistory — file del workspace salvati automaticamente (disabilitate il salvataggio automatico!)
  • rm(list = ls()) — rimuovere tutti gli oggetti per ripartire da un ambiente pulito
  • options(scipen = 999, digits = 4) — controllare la formattazione dei numeri
  • .Renviron — memorizzare chiavi API e percorsi come variabili d'ambiente
  • saveRDS(obj, 'file.rds') — memorizzare nella cache un singolo oggetto
  • readRDS('file.rds') — ripristinare con un nome scelto da voi
  • save(a, b, file = 'session.RData') — raggruppare più oggetti
  • load('session.RData') — ripristinare tutti gli oggetti raggruppati
  • Usare i progetti RStudio per gestire automaticamente la directory di lavoro
# Typical script header for clean, reproducible analysis:
rm(list = ls())                         # clean workspace
options(scipen = 999, digits = 4)       # formatting

# Load secrets from .Renviron:
db_url <- Sys.getenv('DATABASE_URL')

# Load cached data if available:
cache_file <- file.path('cache', 'processed_data.rds')
if (file.exists(cache_file)) {
  df <- readRDS(cache_file)
  cat('Loaded from cache\n')
} else {
  cat('Cache not found, run data_prep.R first\n')
}

cat('Workspace ready')

Domande Frequenti

La lezione «Progetti R e gestione dell'area di lavoro» è gratuita?

Sì — il testo completo di «Progetti R e gestione dell'area di lavoro» è 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 «Progetti R e gestione dell'area di lavoro»?

Crei progetti RStudio e gestisca .RData, .Rhistory e .Renviron. 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 «Progetti R e gestione dell'area di lavoro»?

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. Uso di source() per caricare gli script
  2. Commenti, stile e leggibilità
  3. Directory di lavoro e percorsi dei file
  4. Progetti R e gestione dell'area di lavoro
← Torna a R Academy