R Academy · Lección

Comentarios, estilo y legibilidad

Escriba código R limpio y documentado siguiendo la guía de estilo de tidyverse.

Lección 2 de 413 pasos

Comentarios, estilo y legibilidad es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 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.

Comentarios de una sola línea con #

En R, el carácter # inicia un comentario. Todo lo que aparece desde # hasta el final de la línea es ignorado por el intérprete. Los comentarios están destinados a las personas: explique por qué, no solo qué.

# This is a comment — R ignores it completely
x <- 42   # inline comment after code

# Bad comment (states the obvious):
y <- y + 1   # add 1 to y

# Good comment (explains intent):
y <- y + 1   # shift index to 1-based for output display

cat('x =', x)

Encabezados de sección con ------

Una convención muy extendida en R consiste en crear encabezados de sección añadiendo al menos cuatro guiones, signos igual o almohadillas después del texto del comentario. RStudio los reconoce y los añade al esquema del documento para facilitar la navegación.

# Data Loading -------------------------------------------------------

# This section loads raw CSV files from the data/ folder

# Data Cleaning =======================================================

# Remove duplicates and fix missing values

# Modeling ############################################################

# Fit linear model and evaluate

cat('Section headers improve navigation')

Convención de nombres snake_case

La guía de estilo de tidyverse recomienda usar snake_case para todos los nombres de objetos: palabras en minúsculas separadas por guiones bajos. Evite los puntos, que en otros lenguajes parecen llamadas a métodos, y también camelCase para mantener la coherencia.

# Good: snake_case
user_age <- 25
monthly_revenue <- 15000
calculate_mean <- function(x) mean(x)

# Avoid: dots in names (looks like OOP method calls)
user.age <- 25       # confusing

# Avoid: camelCase (inconsistent with tidyverse)
userAge <- 25

# Avoid: ALL_CAPS (reserved for true constants by convention)
MAX_RETRIES <- 3     # acceptable for config constants only

cat('snake_case wins')

Espacios alrededor de los operadores

Coloque siempre espacios alrededor de los operadores de asignación y comparación. Esto mejora considerablemente la legibilidad. La única excepción se da dentro de las listas de argumentos de funciones, donde = vincula los nombres de los argumentos.

# Good: spaces around <- and operators
x <- 10
y <- x + 5
result <- x * y - 2
is_valid <- x > 0 & y < 100

# Bad: cramped
x<-10
y<-x+5

# Function arguments: = without extra spaces is fine
mean(x = c(1, 2, 3), na.rm = TRUE)

# Comparison operators also need spaces
if (x > 0) cat('positive')
if (x >= 0 & y <= 100) cat('in range')

Use <-, no =, para asignar

Aunque R permite usar = para asignar en el nivel superior, la convención general de la comunidad es usar <- para asignar objetos y reservar = exclusivamente para los valores de los argumentos de funciones. Esta distinción facilita mucho la lectura del código de un vistazo.

# Correct: <- for assignment
name <- 'Alice'
score <- 95.5
results <- c(1, 2, 3)

# Correct: = inside function calls
round(3.14159, digits = 2)
read.csv('data.csv', header = TRUE, sep = ',')

# Avoid: = for top-level assignment
# name = 'Alice'   <- works but not idiomatic

cat('Assignment convention:', name, score)

Límite de 80 caracteres por línea

Mantener las líneas por debajo de 80 caracteres garantiza que el código sea legible en editores con paneles divididos, páginas impresas y herramientas de revisión de código. En RStudio puede mostrar una guía de margen en la columna 80 mediante Tools → Global Options → Code → Display.

# Bad: one very long line (hard to read)
result <- some_function(argument_one = 'value', argument_two = 100, argument_three = TRUE, argument_four = 'long_string')

# Good: break at commas, indent continuation
result <- some_function(
  argument_one   = 'value',
  argument_two   = 100,
  argument_three = TRUE,
  argument_four  = 'long_string'
)

cat('Readable at 80 chars')

Sin punto y coma

A diferencia de JavaScript o C, R no requiere puntos y coma al final de las instrucciones. Puede usar puntos y coma para colocar varias instrucciones en una línea, pero la guía de estilo indica: una instrucción por línea y sin puntos y coma.

# Bad: semicolons and multiple statements per line
x <- 1; y <- 2; z <- x + y

# Good: one statement per line
x <- 1
y <- 2
z <- x + y

# The semicolon form is only acceptable in very short
# interactive throwaway code, never in scripts
cat('z =', z)

Nombres de variables legibles

Elija nombres descriptivos sin que sean excesivamente largos. Una buena regla es la siguiente: si seis meses después necesita pensar durante más de un segundo para entender el nombre de una variable, este es demasiado corto o críptico.

# Too cryptic:
d <- read.csv('data.csv')
tmp <- d[d$v1 > 0, ]
r <- lm(v2 ~ v1, data = tmp)

# Good names:
sales_data    <- read.csv('data.csv')
positive_rows <- sales_data[sales_data$revenue > 0, ]
revenue_model <- lm(profit ~ revenue, data = positive_rows)

# Avoid abbreviations that are not universally understood:
# n_obs is fine (number of observations)
# nrv is not (nobody knows what this is)

cat('Names tell the story')

Llaves y sangría

La guía de estilo de tidyverse especifica lo siguiente: la llave de apertura { debe estar en la misma línea y la llave de cierre }, en su propia línea. Use 2 espacios para la sangría, no tabuladores. Una sangría coherente es fundamental para leer la lógica anidada.

# Good style: brace on same line, 2-space indent
if (x > 0) {
  cat('positive\n')
} else {
  cat('non-positive\n')
}

# Good function definition:
calculate_bmi <- function(weight_kg, height_m) {
  bmi <- weight_kg / height_m^2
  round(bmi, 1)
}

cat('BMI:', calculate_bmi(70, 1.75))

Espaciado dentro de corchetes y alrededor de comas

Coloque un espacio después de cada coma, como en la escritura en inglés, pero no deje espacio antes de una coma ni justo dentro de los corchetes. Esto reproduce la notación matemática y facilita la lectura de la indexación.

# Good: space after comma, not before
x <- c(1, 2, 3, 4, 5)
m <- matrix(1:9, nrow = 3, ncol = 3)

# Subsetting: no space before [ or inside []
first_row <- m[1, ]      # good
value     <- m[2, 3]    # good

# Bad:
# c(1,2,3)     <- no space after comma
# m[ 1, ]      <- space after [
# m[1 , ]      <- space before comma

cat('Spacing is consistent')

Uso de styler y lintr

Dos herramientas automatizan la aplicación del estilo en R. styler reformatea el código para adaptarlo a la guía de estilo de tidyverse. lintr comprueba estáticamente el código para detectar problemas de estilo y posibles errores sin ejecutarlo. Ambas se integran con RStudio.

# styler: reformat a file automatically
# install.packages('styler')
# styler::style_file('my_script.R')

# styler: reformat the whole project
# styler::style_dir('R/')

# lintr: check for style and potential bugs
# install.packages('lintr')
# lintr::lint('my_script.R')

# lintr reports issues like:
#   line 10: [object_name_linter] Variable 'myVar' should use snake_case
#   line 15: [spaces_around_ops_linter] No space before '<-'

cat('Style tools: styler + lintr')

Comprobación rápida

Según la guía de estilo de tidyverse, ¿cuál de las siguientes es la forma correcta de escribir una instrucción de asignación en R?

Estilo y legibilidad: conclusiones clave

El código de R bien estructurado es profesional, fácil de mantener y favorece la colaboración:

  • # para los comentarios: explique por qué, no solo qué
  • Encabezados de sección con ------ o ====== para facilitar la navegación
  • snake_case para todos los nombres de objetos y funciones
  • Espacios alrededor de <-, +, ==, etc.
  • Use <- para asignar y = solo en los argumentos de funciones
  • Máximo de 80 caracteres por línea: divida las llamadas largas en varias líneas
  • Sin puntos y coma: una instrucción por línea
  • Sangría de 2 espacios y { de apertura en la misma línea
  • Use styler para dar formato automáticamente y lintr para detectar problemas
# Putting it all together:

# Calculate summary statistics ----------------------------------------
calculate_summary <- function(values, remove_na = TRUE) {
  cleaned <- values[!is.na(values)]
  list(
    mean   = mean(cleaned),
    median = median(cleaned),
    sd     = sd(cleaned)
  )
}

test_scores <- c(85, 90, NA, 78, 92, 88)
stats <- calculate_summary(test_scores)
cat('Mean:', stats$mean, '\n')
cat('SD:  ', stats$sd)
Gratis para empezar

Aprende R con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
43
Lecciones
159

Preguntas frecuentes

¿La lección «Comentarios, estilo y legibilidad» es gratis?

Sí — el texto completo de «Comentarios, estilo y legibilidad» 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 «Comentarios, estilo y legibilidad»?

Escriba código R limpio y documentado siguiendo la guía de estilo de tidyverse. 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 2 de 4.

¿Cuánto tiempo toma la lección «Comentarios, estilo y legibilidad»?

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