0Pricing
R Academy · Lezione

Precedenza degli operatori ed espressioni complesse

Comprenda l'ordine di valutazione e scriva espressioni complesse in sicurezza.

Precedenza degli operatori ed espressioni complesse è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cos’è la precedenza degli operatori?

La precedenza degli operatori determina l’ordine in cui vengono valutate le operazioni in un’espressione. Proprio come in matematica, la moltiplicazione viene valutata prima dell’addizione. R segue una tabella di precedenza ben definita.

# 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

Tabella della precedenza in R (da alta a bassa)

R valuta gli operatori in questo ordine (dalla priorità più alta):

  1. ^ — elevamento a potenza
  2. - (unario) — negazione
  3. : — sequenza
  4. %%, %/%, %*%, %in% — operatori infissi speciali
  5. *, / — moltiplicazione, divisione
  6. +, - (binari) — addizione, sottrazione
  7. <, >, <=, >=, ==, != — confronto
  8. ! — NOT
  9. &, && — AND
  10. |, || — OR
  11. <-, = — assegnazione
# 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

Precedenza dell’operatore due punti

L’operatore di sequenza : ha una precedenza maggiore di + e -, causando un errore comune tra i principianti: 1:n+1 viene interpretato come (1:n)+1, non come 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

Precedenza degli operatori speciali

Gli operatori speciali come %%, %/% e %in% hanno una precedenza maggiore di + e -, ma minore di ^. Non comprenderla può causare bug difficili da individuare.

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

Confronti prima della logica

Gli operatori di confronto (<, >, == ecc.) vengono valutati prima degli operatori logici (!, &, |). Per questo x > 0 & y < 10 funziona come previsto senza parentesi aggiuntive.

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

Bug di precedenza insidioso n. 1

Un bug comune consiste nel dimenticare che ! ha una precedenza inferiore rispetto al confronto: !x == y viene quindi interpretato come (!x) == y, non come !(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)

Bug di precedenza insidioso n. 2

Un altro bug difficile da notare: -1:5 crea la sequenza -1, 0, 1, 2, 3, 4, 5; il meno unario si applica solo a 1, non all’intero intervallo. Per ottenere un intervallo che inizi da un numero negativo, usi le parentesi.

# 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

Usare le parentesi per chiarezza

Anche quando non sono strettamente necessarie, le parentesi rendono il codice più facile da leggere e meno soggetto a errori. Non faccia affidamento sulla memorizzazione dell’intera tabella di precedenza: usi le parentesi per esprimere chiaramente l’intento.

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

Assegnazione nelle espressioni

L’assegnazione (<-) ha una precedenza molto bassa, inferiore a quella della maggior parte degli operatori. Questo permette di assegnare in una sola riga il risultato di un’espressione complessa, ma fa anche sì che l’assegnazione all’interno delle espressioni possa comportarsi in modo inatteso.

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

Esercitazione: evitare gli errori di precedenza

Ecco una strategia pratica per scrivere correttamente espressioni complesse: suddivida le espressioni lunghe in passaggi intermedi denominati. Questo facilita anche il debug, perché può esaminare ogni passaggio.

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

Precedenza con AND/OR logici

& (AND) ha una precedenza maggiore di | (OR). Pertanto A | B & C viene valutato come A | (B & C). Usi sempre le parentesi quando combina AND e OR, per evitare bug logici difficili da individuare.

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 rapida

A quale valore viene valutato -3 ^ 2 in R?

Riepilogo: precedenza degli operatori

Ottimo! Ecco i concetti principali di questa lezione:

  • Ordine di precedenza (da alta a bassa): ^, - unario, :, %%/%/%*%%in%, */, +-, confronti, !, &, |, assegnazione
  • -2^2 = -4 perché ^ ha precedenza sul meno unario; usi (-2)^2 per ottenere 4
  • 1:n+1 significa (1:n)+1; usi 1:(n+1) se desidera un intervallo più lungo
  • & ha una precedenza maggiore di |; racchiuda tra parentesi la logica AND/OR combinata
  • In caso di dubbio, usi le parentesi per rendere esplicito l’intento ed evitare bug
# 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, '
')

Domande Frequenti

La lezione «Precedenza degli operatori ed espressioni complesse» è gratuita?

Sì — il testo completo di «Precedenza degli operatori ed espressioni complesse» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Precedenza degli operatori ed espressioni complesse»?

Comprenda l'ordine di valutazione e scriva espressioni complesse in sicurezza. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Precedenza degli operatori ed espressioni complesse»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Operatori aritmetici e di confronto
  2. Operatori logici e logica booleana
  3. Operatori di assegnazione e speciali
  4. Precedenza degli operatori ed espressioni complesse
← Torna a R Academy