0Pricing
R Academy · Lección

Proyectos de R y gestión del espacio de trabajo

Cree proyectos de RStudio y gestione .RData, .Rhistory y .Renviron.

Proyectos de R y gestión del espacio de trabajo es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

El espacio de trabajo de R: .RData y .Rhistory

De forma predeterminada, al salir de R se le pregunta si desea guardar el espacio de trabajo — todos los objetos en memoria — en un archivo oculto llamado .RData dentro del directorio de trabajo. El historial de comandos se guarda en .Rhistory. Estos archivos se cargan automáticamente en la siguiente sesión.

Esta comodidad también puede ser una trampa para la reproducibilidad.

# .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

¿Por qué evitar el guardado automático de .RData?

Depender de .RData significa que los resultados no se pueden reproducir desde cero. Los objetos se acumulan de forma invisible entre sesiones, las variables antiguas ocultan a las nuevas y los colaboradores no pueden replicar su entorno. La solución: no guardar nunca el espacio de trabajo; recréelo siempre ejecutando sus scripts.

# 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() — Limpiar el espacio de trabajo

rm(list = ls()) es la forma estándar de eliminar todos los objetos del entorno global y simular una sesión nueva sin reiniciar R. Suele colocarse al principio de un script para garantizar un estado limpio en cada ejecución.

# 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() — Configuración global de la sesión

options() controla muchos comportamientos de R que se aplican a toda la sesión. Dos de las opciones que se configuran con más frecuencia son scipen (penalización de la notación científica) y digits (número de dígitos significativos que se muestran). Configúrelas al principio de los scripts para obtener resultados coherentes.

# 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 — Variables de entorno

El archivo .Renviron almacena las variables de entorno que R carga al iniciarse. Es el lugar adecuado para guardar secretos y valores de configuración, como claves de API, contraseñas de bases de datos y rutas del sistema de archivos, manteniéndolos fuera del código fuente.

# .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() — Guardar un solo objeto

saveRDS() serializa un único objeto de R en un archivo .rds. Es la forma preferida de almacenar en caché los resultados de cálculos costosos, ya que el archivo contiene exactamente un objeto y usted controla exactamente qué guarda y qué carga.

# 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() — Restaurar un solo objeto

readRDS() deserializa un archivo .rds y lo convierte de nuevo en un objeto de R. A diferencia de load(), su valor devuelto debe asignarse a un nombre, por lo que puede cargar el mismo archivo con nombres diferentes en distintas partes del código.

# 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() y load() — Varios objetos

save() serializa uno o más objetos con nombre en un archivo .RData. load() los restaura, pero los nombres originales se restauran automáticamente, lo que puede sobrescribir objetos existentes de forma silenciosa. Utilícelas con precaución.

# 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 frente a save — Cuándo usar cada una

Use saveRDS() para objetos individuales cuando quiera controlar completamente el nombre al cargarlos; es ideal para resultados de modelos, conjuntos de datos procesados y resultados almacenados en caché. Use save() únicamente cuando necesite agrupar varios objetos con nombre para un flujo de trabajo específico con un colaborador.

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

Comprobar y restaurar options()

Las opciones configuradas durante una sesión solo persisten durante esa sesión. Para que su script sea autosuficiente, establezca las opciones que necesite al principio y, opcionalmente, restaure los valores anteriores cuando termine el script mediante 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')

Proyectos de RStudio para gestionar el espacio de trabajo

Un proyecto de RStudio (archivo .Rproj) establece automáticamente el directorio de trabajo en la raíz del proyecto, mantiene un .Rhistory independiente para cada proyecto y aísla las opciones de la sesión. Es la forma estándar de gestionar proyectos de R autosuficientes.

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

Comprobación rápida

Quiere guardar en disco un único data frame de R llamado clean_data para poder volver a cargarlo en otro script con el nombre de variable que elija. ¿Qué función debería utilizar?

Gestión del espacio de trabajo — conclusiones clave

Un espacio de trabajo de R bien gestionado es la base de un análisis reproducible:

  • .RData / .Rhistory — archivos del espacio de trabajo guardados automáticamente (¡desactive el guardado automático!)
  • rm(list = ls()) — eliminar todos los objetos para empezar desde cero
  • options(scipen = 999, digits = 4) — controlar el formato de los números
  • .Renviron — almacenar claves de API y rutas como variables de entorno
  • saveRDS(obj, 'file.rds') — almacenar en caché un único objeto
  • readRDS('file.rds') — restaurarlo con el nombre que elija
  • save(a, b, file = 'session.RData') — agrupar varios objetos
  • load('session.RData') — restaurar todos los objetos agrupados
  • Usar proyectos de RStudio para gestionar automáticamente el directorio de trabajo
# 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')

Preguntas frecuentes

¿La lección «Proyectos de R y gestión del espacio de trabajo» es gratis?

Sí — el texto completo de «Proyectos de R y gestión del espacio de trabajo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Proyectos de R y gestión del espacio de trabajo»?

Cree proyectos de RStudio y gestione .RData, .Rhistory y .Renviron. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Proyectos de R y gestión del espacio de trabajo»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Uso de source() para cargar scripts
  2. Comentarios, estilo y legibilidad
  3. Directorios de trabajo y rutas de archivos
  4. Proyectos de R y gestión del espacio de trabajo
← Volver a R Academy