Sintaxis de R: lo básico en 5 minutos

Expresiones e impresión automática

R es un lenguaje de expresiones: casi cada línea que escribes produce un valor. En la consola, una expresión escrita por sí sola se evalúa y su valor se imprime automáticamente - sin necesidad de print():

2 + 3
"hello"
sqrt(144)

Cada resultado va precedido de [1] - es R diciéndote la posición del primer valor mostrado, una primera pista de que R piensa en vectores (más abajo). La impresión automática tiene una trampa que vale la pena conocer desde el primer día: se aplica a expresiones sueltas en el nivel superior. La misma expresión dentro del cuerpo de una función o de un bucle for no imprime nada, por eso los scripts usan cat() o print() explícitos para la salida que debes ver.

Asignación: la flecha

El operador de asignación de R es <-, una flecha que apunta al nombre que recibe el valor:

radius <- 5
area <- pi * radius^2

print(area)

Lee radius <- 5 como "radius recibe 5". Sí, = también funciona para la asignación en el nivel superior, y sí, los recién llegados preguntan por qué alguien teclea dos caracteres en lugar de uno. La respuesta es una convención con dientes: todas las guías de estilo importantes, la documentación de R base y prácticamente todo el código R que leerás en tu vida usan <- para asignar, reservando = para un trabajo concreto - nombrar argumentos dentro de llamadas a funciones (siguiente sección). Seguir la convención hace las dos operaciones visualmente distintas. En RStudio, Alt+- (Option+- en macOS) escribe la flecha por ti.

Fíjate en que una asignación no se auto-imprime - area <- 78.5 guarda el valor en silencio. Por eso el fragmento de arriba necesita el print().

Sensibilidad a mayúsculas

R distingue estrictamente entre mayúsculas y minúsculas, tanto en los nombres que creas como en los que proporciona el lenguaje:

value <- 10
Value <- 99

print(value)
print(Value)

Dos variables distintas. Igualmente, mean() es una función y Mean() no existe. Cuando R te reciba con object 'x' not found o could not find function, comprueba las mayúsculas antes que nada - es el error de principiante más común de todos.

Llamadas a funciones y argumentos con nombre

Las funciones se llaman con paréntesis, con los argumentos separados por comas. Los argumentos pueden emparejarse por posición, por nombre, o una mezcla:

numbers <- c(4, 8, 15, 16, 23, 42)

round(mean(numbers), 1)
seq(from = 0, to = 100, by = 25)

La llamada a seq() muestra la sintaxis de argumentos con nombre de R - y aquí es donde = se gana el pan: dentro de una llamada, name = value etiqueta un argumento. Los argumentos con nombre te liberan de recordar el orden de los parámetros y hacen las llamadas autodocumentadas; seq(0, 100, 25) funciona igual pero le dice menos al lector. La convención de trabajo: pasa el primer argumento (normalmente los datos) por posición y nombra el resto.

Obtener ayuda sobre cualquier función está a una pulsación: ?seq en la consola abre su documentación.

Todo es un vector

La idea que hace que R se sienta distinto de otros lenguajes: no hay números sueltos a secas. Incluso 5 es un vector de longitud uno, y las operaciones se aplican elemento a elemento a vectores completos:

c(1, 2, 3) * 2
c(10, 20, 30) + c(1, 2, 3)

celsius <- c(0, 25, 100)
fahrenheit <- celsius * 9 / 5 + 32
print(fahrenheit)

No hay ningún bucle en ninguna parte, y sin embargo cada elemento fue convertido. En la mayoría de los lenguajes eso son tres iteraciones de un bucle for; en R es aritmética. Esto es la vectorización, y lo moldea todo - los operadores de comparación, las funciones de cadenas y las funciones matemáticas funcionan así. Por eso el R idiomático tiene muchos menos bucles de los que esperarías; la historia completa está en vectores.

Llaves y bloques

Los cuerpos de varias líneas - para if, bucles y funciones - se agrupan con llaves {}:

score <- 87

if (score >= 60) {
    grade <- "pass"
} else {
    grade <- "fail"
}

cat("Result:", grade, "\n")

Dos cosas que notar. La condición vive entre paréntesis, y es if a secas, no if: ni if ... then. Y a diferencia de Python, la indentación no significa nada en R - las llaves definen el bloque, la indentación es para los humanos. Omitir las llaves en líneas sueltas es legal pero una fuente clásica de bugs al editar; simplemente úsalas siempre.

Espacios en blanco y puntos y coma

R ignora el espacio en blanco extra, y un salto de línea termina una sentencia - sin necesidad de punto y coma:

a <- 2
b <- 3
total <- a +
    b

print(total)

La división en dos líneas funciona porque la línea 3 termina con +, así que R sabe que la expresión no ha terminado. Esa es la única regla a recordar al partir líneas largas: corta después de un operador o una coma, nunca antes, o R tratará la primera línea como completa. Los puntos y coma existen solo para embutir dos sentencias en una línea (a <- 1; b <- 2) - legal, desaconsejado, fácil de evitar.

Estilo: cómo se escribe el código R

Más allá de la gramática, R tiene fuertes convenciones comunitarias (codificadas en la guía de estilo del tidyverse, que sigue la mayor parte del ecosistema):

• <- para asignar, = solo para argumentos dentro de llamadas.
• Nombres en snake_case: monthly_revenue, no monthlyRevenue ni monthly.revenue. Los puntos son legales en los nombres de R pero es mejor evitarlos - chocan con un patrón de nombres que usan los internos de R.
• Espacios alrededor de los operadores (x <- a * 2, no x<-a*2) y después de las comas.
• Indenta con cuatro espacios dentro de las llaves (algunos equipos usan dos; elige uno y sé consistente).
• Una sentencia por línea.

Nada de esto lo impone el intérprete. Todo esto lo impone cualquiera que lea tu código. La mitad de esta historia que trata de los nombres continúa en variables.

Lo que te llevas

• R evalúa expresiones y auto-imprime las sueltas en la consola - pero no dentro de funciones ni bucles.
• Asigna con <- ("recibe"); usa = solo para nombrar argumentos en llamadas a funciones.
• R distingue completamente entre mayúsculas y minúsculas - las erratas de capitalización causan la mayoría de los primeros errores de "not found".
• Todo es un vector, y las operaciones se aplican elemento a elemento: c(1, 2, 3) * 2 es 2 4 6, sin bucle.
• Las llaves definen bloques, los saltos de línea terminan sentencias, y snake_case más las convenciones de espaciado hacen que tu código se lea como el de todos los demás.

Lo siguiente: los comentarios - cómo anotar código R, y qué hacer ante la ausencia de comentarios de bloque en R.