Cómo ejecutar un script de R: Rscript, source() y RStudio

Dos formas de usar R: consola vs script

R tiene una consola interactiva (un REPL - leer, evaluar, imprimir, repetir): escribes una expresión y R responde de inmediato. Escribir R en una terminal, o mirar el panel inferior de RStudio, te da un prompt > donde cada línea se ejecuta en el momento en que pulsas Enter. La consola es donde exploras - hurgas en los datos, pruebas una línea, miras el resultado.

Un script de R es simplemente un archivo de texto plano con código R, guardado con la extensión .R. Los scripts son donde vive el análisis - una receta reproducible que cualquiera (incluido tu yo del futuro) puede ejecutar de arriba abajo y obtener el mismo resultado.

Un script no tiene nada de exótico. Este es uno completo - ejecútalo:

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

Todo lo que sigue trata de las distintas formas de alimentar a R con un archivo como ese.

Rscript: ejecutar un archivo desde la línea de comandos

R instala una herramienta de línea de comandos llamada Rscript construida exactamente para esto. En una terminal, en la carpeta que contiene tu archivo:

Rscript summary.R

R arranca, ejecuta el archivo de arriba abajo, imprime lo que el script imprima y sale. Este es el caballo de batalla de la automatización - cron jobs, pipelines de datos, servidores, CI - cualquier lugar donde el código se ejecuta sin un humano mirando.

Un comportamiento sorprende a todos alguna vez: en la consola, escribir una expresión suelta como avg imprime su valor automáticamente. Bajo Rscript, una expresión suelta dentro de una función o un bucle puede no imprimir nada - por eso los scripts dicen lo que quieren decir con llamadas explícitas a cat() o print(). Adquiere ese hábito pronto.

source(): ejecutar un archivo desde dentro de R

¿Ya estás dentro de una sesión de R y quieres ejecutar un archivo? Para eso está source():

source("summary.R")

Cada línea del archivo se ejecuta en tu sesión actual, y todo lo que el script define - variables, funciones - permanece disponible después. Ese es el punto: source() es la forma de cargar tus propias funciones auxiliares en una sesión interactiva.

Por defecto source() se ejecuta en silencio salvo por la salida explícita. Para verlo trabajar, haz eco de cada línea a medida que se ejecuta:

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

Fíjate en la ruta relativa: "summary.R" significa "en el directorio de trabajo actual", y dónde está eso depende de cómo iniciaste R. Cuando source() o read.csv() misteriosamente no encuentran un archivo que está justo ahí, el directorio de trabajo es casi siempre el culpable - mira directorio de trabajo.

Ejecutar scripts en RStudio

RStudio te da ambos modos con dos comandos, y vale la pena interiorizar la distinción:

• Run (Ctrl+Enter, Cmd+Enter en macOS) - ejecuta la línea actual o la selección resaltada en la consola. Esta es la marcha de exploración: escribe una línea, ejecútala, mira, ajusta.
• Source (el botón Source, o Ctrl/Cmd+Shift+S) - ejecuta el archivo completo, exactamente como source() en la consola.

La trampa de ejecutar línea por línea con Run es que tu sesión de consola acumula estado - las variables de líneas que luego editaste o borraste siguen vivas, así que el script "funciona" para ti y falla para todos los demás. La prueba honesta de un script es Source en una sesión fresca (Session → Restart R, luego Source). Si sobrevive a eso, es reproducible.

Hacer un script ejecutable (macOS / Linux)

En sistemas tipo Unix puedes convertir un script de R en un comando por derecho propio. Pon una línea shebang al principio del archivo:

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

Luego márcalo como ejecutable una vez, y ejecútalo directamente:

chmod +x summary.R
./summary.R

El shebang le dice al shell qué intérprete ejecuta el archivo; env Rscript encuentra Rscript esté donde esté en el PATH de esa máquina. Como la línea empieza con #, el propio R la lee como un comentario y la ignora.

Pasar argumentos a un script

Los scripts reales reciben entradas - un nombre de archivo, una fecha, un umbral - pasadas después del nombre del script:

Rscript report.R sales.csv 2026

Dentro del script, commandArgs(trailingOnly = TRUE) devuelve tus argumentos como un vector de caracteres (trailingOnly = TRUE descarta los argumentos internos del intérprete - prácticamente siempre lo quieres):

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

Todo llega como texto - "2026", no 2026 - así que convierte con as.numeric() antes de hacer cálculos. Podemos simular la lógica de parseo en una forma ejecutable:

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

¿Cuál deberías usar?

• Explorar datos, probar ideas → la consola, o Run en RStudio.
• Ejecutar tu análisis completo → Source en RStudio, o Rscript en una terminal.
• Cargar tus funciones auxiliares en una sesión → source("helpers.R").
• Automatización, planificadores, pipelines → Rscript, con commandArgs() para las entradas.

La sintaxis de lo que va dentro de esos archivos es la próxima lección - mira sintaxis de R.

Lo que te llevas

• La consola es para explorar; los archivos de script .R son para el análisis reproducible.
• Rscript file.R ejecuta un script desde la línea de comandos; source("file.R") lo ejecuta dentro de una sesión (añade echo = TRUE para verlo).
• En RStudio, Run ejecuta una línea; Source ejecuta el archivo - y Source-en-una-sesión-fresca es la verdadera prueba de reproducibilidad.
• #!/usr/bin/env Rscript + chmod +x hace un script directamente ejecutable; commandArgs(trailingOnly = TRUE) lee sus argumentos como texto.

Lo siguiente: la sintaxis de R - la asignación con <-, las llamadas a funciones y la regla de que todo es un vector.