0Pricing
R Academy · Aula

Projetos R e gerenciamento do espaço de trabalho

Crie projetos do RStudio e gerencie .RData, .Rhistory e .Renviron.

Projetos R e gerenciamento do espaço de trabalho é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O espaço de trabalho do R: .RData e .Rhistory

Por padrão, quando você encerra o R, ele pergunta se deseja salvar o espaço de trabalho — todos os objetos na memória — em um arquivo oculto chamado .RData no diretório de trabalho. Seu histórico de comandos é salvo em .Rhistory. Esses arquivos são carregados automaticamente na sessão seguinte.

Essa conveniência também pode prejudicar a reprodutibilidade.

# .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 que evitar o salvamento automático de .RData?

Depender de .RData significa que seus resultados não podem ser reproduzidos do zero. Objetos se acumulam de forma invisível entre sessões, variáveis antigas ocultam as novas e seus colaboradores não conseguem reproduzir seu ambiente. A solução: nunca salve o espaço de trabalho — sempre recrie-o executando seus 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() — Limpando o espaço de trabalho

rm(list = ls()) é a forma canônica de remover todos os objetos do ambiente global, simulando uma sessão nova sem reiniciar o R. É comum colocá-lo no início de um script para garantir um estado limpo a cada execução.

# 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() — Configurações globais da sessão

options() controla muitos comportamentos que abrangem toda a sessão do R. Duas das opções definidas com mais frequência são scipen (penalidade da notação científica) e digits (número de dígitos significativos exibidos). Defina-as no início dos scripts para obter uma saída consistente.

# 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 — Variáveis de ambiente

O arquivo .Renviron armazena variáveis de ambiente que o R carrega na inicialização. Ele é o local adequado para segredos e valores de configuração, como chaves de API, senhas de banco de dados e caminhos do sistema de arquivos — mantendo-os fora do seu código-fonte.

# .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() — Salvando um único objeto

saveRDS() serializa um único objeto R em um arquivo .rds. É a forma preferida de armazenar em cache resultados de cálculos demorados, pois o arquivo armazena exatamente um objeto e você controla exatamente o que salva e carrega.

# 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() — Restaurando um único objeto

readRDS() desserializa um arquivo .rds de volta para um objeto R. Ao contrário de load(), o valor retornado precisa ser atribuído a um nome — assim, você pode carregar o mesmo arquivo com nomes diferentes em partes distintas do seu 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() e load() — Vários objetos

save() serializa um ou mais objetos nomeados em um arquivo .RData. load() os restaura — mas os nomes originais são restaurados automaticamente, o que pode substituir silenciosamente objetos existentes. Use com 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 versus save — Quando usar cada um

Use saveRDS() para objetos únicos quando quiser controle total sobre a atribuição de nomes ao carregá-los — ideal para resultados de modelos, conjuntos de dados processados e resultados armazenados em cache. Use save() somente quando precisar agrupar vários objetos nomeados para um fluxo de trabalho específico com um 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')

Verificando e restaurando options()

As opções definidas durante uma sessão persistem somente nessa sessão. Para garantir que seu script seja autossuficiente, defina as opções necessárias no início e, opcionalmente, restaure os valores antigos quando o script terminar 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')

Projetos do RStudio para gerenciar o espaço de trabalho

Um projeto do RStudio (arquivo .Rproj) define automaticamente o diretório de trabalho como a raiz do projeto, mantém um .Rhistory separado para cada projeto e isola as opções da sessão. Essa é a forma padrão de gerenciar projetos R autossuficientes.

# 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ção rápida

Você quer salvar em disco um único quadro de dados R chamado clean_data para poder recarregá-lo em outro script com qualquer nome de variável que escolher. Qual função deve usar?

Gerenciamento do espaço de trabalho — principais conclusões

Um espaço de trabalho R bem gerenciado é a base de uma análise reproduzível:

  • .RData / .Rhistory — arquivos do espaço de trabalho salvos automaticamente (desative o salvamento automático!)
  • rm(list = ls()) — remove todos os objetos para começar com um estado limpo
  • options(scipen = 999, digits = 4) — controla a formatação dos números
  • .Renviron — armazena chaves de API e caminhos como variáveis de ambiente
  • saveRDS(obj, 'file.rds') — armazena um único objeto em cache
  • readRDS('file.rds') — restaura o objeto com o nome que você escolher
  • save(a, b, file = 'session.RData') — agrupa vários objetos
  • load('session.RData') — restaura todos os objetos agrupados
  • Use projetos do RStudio para gerenciar automaticamente o diretório de trabalho
# 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')

Perguntas Frequentes

A aula “Projetos R e gerenciamento do espaço de trabalho” é grátis?

Sim — o texto completo de “Projetos R e gerenciamento do espaço de trabalho” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Projetos R e gerenciamento do espaço de trabalho”?

Crie projetos do RStudio e gerencie .RData, .Rhistory e .Renviron. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Projetos R e gerenciamento do espaço de trabalho”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Usando source() para carregar scripts
  2. Comentários, estilo e legibilidade
  3. Diretórios de trabalho e caminhos de arquivos
  4. Projetos R e gerenciamento do espaço de trabalho
← Voltar para R Academy