Como Executar um Script R: Rscript, source() e RStudio

Duas Formas de Usar o R: Console vs Script

O R tem um console interativo (um REPL - read, evaluate, print, loop): você digita uma expressão, e o R responde imediatamente. Digitar R em um terminal, ou olhar para o painel inferior do RStudio, te dá um prompt > onde cada linha é executada no momento em que você pressiona Enter. O console é onde você explora - cutuca os dados, testa uma linha, olha o resultado.

Um script R é apenas um arquivo de texto simples com código R, salvo com a extensão .R. Scripts são onde a análise mora - uma receita reprodutível que qualquer pessoa (incluindo o você do futuro) pode executar de cima a baixo e obter o mesmo resultado.

Um script não é nada exótico. Este é um completo - execute-o:

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

Tudo abaixo trata das diferentes formas de entregar um arquivo como esse para o R.

Rscript: Executar um Arquivo pela Linha de Comando

O R instala uma ferramenta de linha de comando chamada Rscript, construída exatamente para isso. Em um terminal, na pasta que contém o seu arquivo:

Rscript summary.R

O R inicia, executa o arquivo de cima a baixo, imprime o que quer que o script imprima e encerra. Esse é o cavalo de batalha da automação - cron jobs, pipelines de dados, servidores, CI - qualquer lugar onde o código roda sem um humano observando.

Um comportamento surpreende todo mundo uma vez: no console, digitar uma expressão isolada como avg imprime seu valor automaticamente. Sob o Rscript, uma expressão isolada dentro de uma função ou laço pode não imprimir nada - é por isso que scripts dizem o que querem dizer com chamadas explícitas a cat() ou print(). Adquira esse hábito cedo.

source(): Executar um Arquivo de Dentro do R

Já está dentro de uma sessão R e quer executar um arquivo? Para isso existe o source():

source("summary.R")

Cada linha do arquivo é executada na sua sessão atual, e tudo o que o script define - variáveis, funções - permanece disponível depois. Esse é o objetivo: source() é como você carrega suas próprias funções auxiliares em uma sessão interativa.

Por padrão, source() roda em silêncio, exceto pela saída explícita. Para observá-lo trabalhando, ecoe cada linha à medida que ela é executada:

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

Note o caminho relativo: "summary.R" significa "no diretório de trabalho atual", e onde isso fica depende de como você iniciou o R. Quando source() ou read.csv() misteriosamente não encontram um arquivo que está bem ali, o diretório de trabalho é quase sempre o culpado - veja diretório de trabalho.

Executando Scripts no RStudio

O RStudio te dá os dois modos com dois comandos, e vale a pena internalizar a distinção:

• Run (Ctrl+Enter, Cmd+Enter no macOS) - executa a linha atual ou a seleção destacada no console. Esta é a marcha de exploração: escreva uma linha, execute, olhe, ajuste.
• Source (o botão Source, ou Ctrl/Cmd+Shift+S) - executa o arquivo inteiro, exatamente como source() no console.

A armadilha do Run linha a linha é que sua sessão de console acumula estado - variáveis de linhas que você depois editou ou apagou continuam vivas, então o script "funciona" para você e falha para todo mundo. O teste honesto de um script é o Source em uma sessão nova (Session → Restart R, depois Source). Se ele sobreviver a isso, é reprodutível.

Tornando um Script Executável (macOS / Linux)

Em sistemas do tipo Unix, você pode transformar um script R em um comando próprio. Coloque uma linha shebang bem no topo do arquivo:

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

Depois, marque-o como executável uma vez e execute-o diretamente:

chmod +x summary.R
./summary.R

O shebang diz ao shell qual interpretador executa o arquivo; env Rscript encontra o Rscript onde quer que ele esteja no PATH daquela máquina. Como a linha começa com #, o próprio R a lê como um comentário e a ignora.

Passando Argumentos para um Script

Scripts de verdade recebem entradas - um nome de arquivo, uma data, um limite - passadas depois do nome do script:

Rscript report.R sales.csv 2026

Dentro do script, commandArgs(trailingOnly = TRUE) retorna seus argumentos como um vetor de caracteres (trailingOnly = TRUE descarta os argumentos internos do próprio interpretador - você praticamente sempre vai querer isso):

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

Tudo chega como texto - "2026", não 2026 - então converta com as.numeric() antes de fazer contas. Podemos simular a lógica de parsing em uma forma executável:

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

Qual Você Deve Usar?

• Explorar dados, testar ideias → o console, ou Run no RStudio.
• Executar sua análise inteira → Source no RStudio, ou Rscript em um terminal.
• Carregar suas funções auxiliares em uma sessão → source("helpers.R").
• Automação, agendadores, pipelines → Rscript, com commandArgs() para as entradas.

A sintaxe do que vai dentro desses arquivos é a próxima lição - veja sintaxe do R.

O Que Você Leva Daqui

• O console é para explorar; arquivos de script .R são para análise reprodutível.
• Rscript file.R executa um script pela linha de comando; source("file.R") o executa dentro de uma sessão (adicione echo = TRUE para observar).
• No RStudio, Run executa uma linha; Source executa o arquivo - e Source em uma sessão nova é o verdadeiro teste de reprodutibilidade.
• #!/usr/bin/env Rscript + chmod +x torna um script diretamente executável; commandArgs(trailingOnly = TRUE) lê seus argumentos como texto.

A seguir: a sintaxe do R - atribuição com <-, chamadas de função e a regra de que tudo é um vetor.