PricingLoginStart free
R Academy · Aula

Precedência de operadores e expressões complexas

Entenda a ordem de avaliação e escreva expressões complexas com segurança.

Aula 4 de 413 etapas

Precedência de operadores e expressões complexas é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O que é precedência de operadores?

A precedência de operadores determina a ordem em que as operações são avaliadas em uma expressão. Assim como na matemática, a multiplicação é avaliada antes da adição. R segue uma tabela de precedência bem 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

Tabela de precedência do R (da maior para a menor)

R avalia os operadores nesta ordem (da maior prioridade para a menor):

  1. ^ — exponenciação
  2. - (unário) — negação
  3. : — sequência
  4. %%, %/%, %*%, %in% — infixos especiais
  5. *, / — multiplicação, divisão
  6. +, - (binários) — adição, subtração
  7. <, >, <=, >=, ==, != — comparação
  8. ! — NOT
  9. &, && — AND
  10. |, || — OR
  11. <-, = — atribuição
# 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

Precedência do operador de dois-pontos

O operador de sequência : tem precedência maior que + e -, o que causa um erro comum entre iniciantes: 1:n+1 é interpretado como (1:n)+1, e não 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

Precedência de operadores especiais

Operadores especiais como %%, %/% e %in% têm precedência maior que + e -, mas menor que ^. Não entender isso pode causar erros sutis.

# %% 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

Comparação antes da lógica

Os operadores de comparação (<, >, == etc.) são avaliados antes dos operadores lógicos (!, &, |). Isso significa que x > 0 & y < 10 funciona como esperado sem parênteses adicionais.

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), '
')

Erro sutil de precedência nº 1

Um erro comum é esquecer que ! tem precedência menor que a comparação; portanto, !x == y é interpretado como (!x) == y, e não 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)

Erro sutil de precedência nº 2

Outro erro sutil: -1:5 cria a sequência -1, 0, 1, 2, 3, 4, 5 — o sinal unário de menos se aplica apenas a 1, e não a todo o intervalo. Para obter um intervalo que comece com um valor negativo, use parênteses.

# 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

Usando parênteses para maior clareza

Mesmo quando os parênteses não são estritamente necessários, usá-los torna o código mais fácil de ler e menos sujeito a erros. Nunca dependa da memorização da tabela completa de precedência — use parênteses para expressar claramente sua intenção.

# 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, '
')

Atribuição em expressões

A atribuição (<-) tem precedência muito baixa — menor que a da maioria dos operadores. Isso permite atribuir o resultado de qualquer expressão complexa em uma única linha, mas também faz com que a atribuição dentro de expressões tenha um comportamento inesperado.

# <- 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ática: evitando erros de precedência

Aqui está uma estratégia prática para escrever expressões complexas corretas: divida expressões longas em etapas intermediárias nomeadas. Isso também facilita a depuração, pois você pode inspecionar cada etapa.

# 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), '
')

Precedência com AND/OR lógicos

& (AND) tem precedência maior que | (OR). Portanto, A | B & C é avaliado como A | (B & C). Sempre use parênteses ao combinar AND e OR para evitar erros lógicos sutis.

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

Verificação rápida

Qual é o resultado de -3 ^ 2 em R?

Responda na aula interativa

Revisão: precedência de operadores

Excelente! Veja os principais aprendizados desta lição:

  • Ordem de precedência (da maior para a menor): ^, - unário, :, %%/%/%*%%in%, */, +-, comparações, !, &, |, atribuição
  • -2^2 = -4 porque ^ tem precedência maior que o menos unário — use (-2)^2 para obter 4
  • 1:n+1 significa (1:n)+1 — use 1:(n+1) se quiser um intervalo maior
  • & tem precedência maior que | — use parênteses em lógicas que combinem AND e OR
  • Quando tiver dúvida, use parênteses para tornar sua intenção explícita e evitar erros
# 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, '
')
Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
43
Aulas
159
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Precedência de operadores e expressões complexas” é grátis?

Sim — o texto completo de “Precedência de operadores e expressões complexas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Precedência de operadores e expressões complexas”?

Entenda a ordem de avaliação e escreva expressões complexas com segurança. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Precedência de operadores e expressões complexas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Operadores aritméticos e de comparação
  2. Operadores lógicos e lógica booleana
  3. Atribuição e operadores especiais
  4. Precedência de operadores e expressões complexas
← Voltar para R Academy