PricingLoginStart free
R Academy · Lección

Precedencia de operadores y expresiones complejas

Comprenda el orden de evaluación y escriba expresiones complejas de forma segura.

Lección 4 de 413 pasos

Precedencia de operadores y expresiones complejas es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 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.

¿Qué es la precedencia de operadores?

La precedencia de operadores determina el orden en que se evalúan las operaciones de una expresión. Al igual que en matemáticas, la multiplicación se evalúa antes que la suma. R sigue una tabla de precedencia bien definida.

# Precedence in action
result1 <- 2 + 3 * 4    # * before +
result2 <- (2 + 3) * 4  # parentheses override
cat('2 + 3 * 4 =', result1, '
')   # 14
cat('(2+3) * 4 =', result2, '
')   # 20

Tabla de precedencia de R (de mayor a menor)

R evalúa los operadores en este orden (primero la prioridad más alta):

  1. ^ — exponenciación
  2. - (unario) — negación
  3. : — secuencia
  4. %%, %/%, %*%, %in% — operadores infijos especiales
  5. *, / — multiplicación, división
  6. +, - (binarios) — suma, resta
  7. <, >, <=, >=, ==, != — comparación
  8. ! — NOT
  9. &, && — AND
  10. |, || — OR
  11. <-, = — asignación
# Exponentiation before multiplication
cat('2 * 3 ^ 2 =', 2 * 3 ^ 2, '
')   # 2 * 9 = 18
cat('(2*3)^2 =', (2 * 3) ^ 2, '
')   # 6^2 = 36

# Unary minus applied after exponentiation
cat('-2 ^ 2 =', -2 ^ 2, '
')    # -(2^2) = -4
cat('(-2)^2 =', (-2) ^ 2, '
')  # 4

Precedencia del operador de dos puntos

El operador de secuencia : tiene mayor precedencia que + y -, lo que provoca un error común entre principiantes: 1:n+1 se interpreta como (1:n)+1, no como 1:(n+1).

n <- 5

# Common mistake: colon before addition
cat('1:n+1 =', 1:n + 1, '
')   # (1:5)+1 = 2 3 4 5 6
cat('1:(n+1) =', 1:(n + 1), '
') # 1:6 = 1 2 3 4 5 6

# These are DIFFERENT results!
# Always use parentheses when the upper bound involves arithmetic

Precedencia de operadores especiales

Los operadores especiales, como %%, %/% y %in%, tienen mayor precedencia que + y -, pero menor que ^. No tener esto en cuenta provoca errores sutiles.

# %% has higher precedence than +
cat('10 + 7 %% 3 =', 10 + 7 %% 3, '
')   # 10 + (7%%3) = 10+1 = 11
cat('(10+7) %% 3 =', (10 + 7) %% 3, '
') # 17 %% 3 = 2

# %in% precedence
nums <- 1:5
cat('1 + 1 %in% nums =', 1 + 1 %in% nums, '
')  # (1+1) %in% nums? No! 1 + (1 %in% nums) = 2

Comparación antes que lógica

Los operadores de comparación (<, >, ==, etc.) se evalúan antes que los operadores lógicos (!, &, |). Por eso x > 0 & y < 10 funciona como se espera sin paréntesis adicionales.

x <- 5
y <- 8

# This works as intended: comparisons first, then &
cat('x > 0 & y < 10:', x > 0 & y < 10, '
')  # TRUE & TRUE = TRUE

# ! NOT has higher precedence than &
vec <- c(TRUE, FALSE, TRUE)
cat('!vec & TRUE:', !vec & TRUE, '
')  # (!vec) & TRUE, not !(vec & TRUE)
cat('!(vec & TRUE):', !(vec & TRUE), '
')

Error de precedencia complicado n.º 1

Un error común consiste en olvidar que ! tiene menor precedencia que la comparación; por tanto, !x == y se interpreta como (!x) == y, no como !(x == y).

x <- 5
y <- 5

# BUG: meant to check 'x is not equal to y'
bug_result <- !x == y      # reads as (!x) == y
cat('!x == y (bug):', bug_result, '
')   # !5 means FALSE, FALSE==5 is FALSE

# CORRECT: use != or !(x == y)
cat('x != y:', x != y, '
')             # FALSE (correct)
cat('!(x == y):', !(x == y), '
')       # FALSE (correct)

Error de precedencia complicado n.º 2

Otro error sutil: -1:5 crea la secuencia -1, 0, 1, 2, 3, 4, 5; el signo menos unario solo se aplica a 1, no a todo el intervalo. Para obtener un intervalo que empiece en un número negativo, use paréntesis.

# Misleading: looks like range from -1 to 5 starting at negative
seq1 <- -1:5
cat('-1:5 =', seq1, '
')  # -1 0 1 2 3 4 5 (correct here)

# But -2^2 is a trap:
cat('-2^2 =', -2 ^ 2, '
')    # -4 (not 4)
cat('(-2)^2 =', (-2) ^ 2, '
') # 4

# Always parenthesise to be safe
cat('(-1):5 =', (-1):5, '
')   # same as -1:5 but explicit

Uso de paréntesis para mayor claridad

Aunque los paréntesis no sean estrictamente necesarios, utilizarlos hace que el código sea más fácil de leer y menos propenso a errores. No dependa de memorizar toda la tabla de precedencia: use paréntesis para expresar claramente su intención.

# Hard to read — requires knowing precedence
result_unclear <- 2 + 3 * 4 ^ 2 / 8 - 1

# Clear intent with parentheses
result_clear <- 2 + ((3 * (4 ^ 2)) / 8) - 1

cat('Unclear:', result_unclear, '
')
cat('Clear:  ', result_clear, '
')
cat('Same result?', result_unclear == result_clear, '
')

Asignación en expresiones

La asignación (<-) tiene una precedencia muy baja, menor que la de la mayoría de los operadores. Esto permite asignar en una sola línea el resultado de cualquier expresión compleja, pero también significa que la asignación dentro de expresiones puede comportarse de forma inesperada.

# <- has very low precedence
# This assigns (3 + 4) to x, then evaluates (TRUE)
result <- x <- 3 + 4   # x gets 7, result gets 7
cat('x:', x, 'result:', result, '
')

# Be careful with == vs <- 
# x <- 5 is assignment
# x == 5 is comparison (always use == for testing)

Práctica: evitar errores de precedencia

Esta es una estrategia práctica para escribir expresiones complejas correctas: divida las expresiones largas en pasos intermedios con nombre. Esto también facilita la depuración, ya que puede inspeccionar cada paso.

# Complex formula: compound interest
principal <- 1000
rate <- 0.05
years <- 10

# Hard to verify in one line
bad <- principal * (1 + rate) ^ years

# Easier to verify step by step
growth_factor <- (1 + rate) ^ years
final_amount <- principal * growth_factor
cat('Growth factor:', round(growth_factor, 4), '
')
cat('Final amount: $', round(final_amount, 2), '
')

Precedencia con AND/OR lógicos

& (AND) tiene mayor precedencia que | (OR). Por tanto, A | B & C se evalúa como A | (B & C). Use siempre paréntesis al combinar AND y OR para evitar errores lógicos sutiles.

A <- TRUE
B <- FALSE
C <- TRUE

# & before | — may surprise you
cat('A | B & C:', A | B & C, '
')     # A | (B & C) = TRUE | FALSE = TRUE
cat('(A|B) & C:', (A | B) & C, '
')   # TRUE & TRUE = TRUE

# Different with:
A2 <- FALSE
cat('A2 | B & C:', A2 | B & C, '
')   # FALSE | (FALSE & TRUE) = FALSE
cat('(A2|B) & C:', (A2 | B) & C, '
') # (FALSE|FALSE) & TRUE = FALSE

Comprobación rápida

¿A qué valor se evalúa -3 ^ 2 en R?

Responde en la lección interactiva

Recapitulación: precedencia de operadores

¡Excelente! Estas son las ideas clave de esta lección:

  • Orden de precedencia (de mayor a menor): ^, - unario, :, %%/%/%*%%in%, */, +-, comparaciones, !, &, |, asignación
  • -2^2 = -4 porque ^ tiene prioridad sobre el signo menos unario; use (-2)^2 para obtener 4
  • 1:n+1 significa (1:n)+1; use 1:(n+1) si desea un intervalo más largo
  • & tiene mayor precedencia que |; use paréntesis en la lógica que combine AND y OR
  • En caso de duda, use paréntesis para hacer explícita su intención y evitar errores
# Golden rule: parentheses for clarity
n <- 4
# Intended: sequence 1 to n+1
cat('Wrong : 1:n+1  =', 1:n + 1, '
')
cat('Correct: 1:(n+1)=', 1:(n + 1), '
')

# Intended: -(2^2)
cat('Correct: -2^2 = -(2^2) =', -2 ^ 2, '
')
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
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Precedencia de operadores y expresiones complejas» es gratis?

Sí — el texto completo de «Precedencia de operadores y expresiones complejas» 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 «Precedencia de operadores y expresiones complejas»?

Comprenda el orden de evaluación y escriba expresiones complejas de forma segura. 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 4 de 4.

¿Cuánto tiempo toma la lección «Precedencia de operadores y expresiones complejas»?

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. Operadores aritméticos y de comparación
  2. Operadores lógicos y lógica booleana
  3. Operadores de asignación y especiales
  4. Precedencia de operadores y expresiones complejas
← Volver a R Academy