Priorité des opérateurs et expressions complexes
Comprenez l’ordre d’évaluation et écrivez des expressions complexes en toute sécurité.
Priorité des opérateurs et expressions complexes est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.
Qu’est-ce que la priorité des opérateurs ?
La priorité des opérateurs détermine l’ordre dans lequel les opérations sont évaluées dans une expression. Comme en mathématiques, la multiplication est évaluée avant l’addition. R suit une table de priorités bien définie.
# 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, '
') # 20Table des priorités de R (de la plus élevée à la plus faible)
R évalue les opérateurs dans l’ordre suivant (en commençant par la priorité la plus élevée) :
^— exponentiation-(unaire) — négation:— séquence%%, %/%, %*%, %in%— opérateurs infixes spéciaux*, /— multiplication, division+, -(binaires) — addition, soustraction<, >, <=, >=, ==, !=— comparaison!— NOT&, &&— AND|, ||— OR<-, =— affectation
# 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, '
') # 4Priorité de l’opérateur deux-points
L’opérateur de séquence : a une priorité supérieure à celle de + et -, ce qui entraîne une erreur fréquente chez les débutants : 1:n+1 est interprété comme (1:n)+1, et non comme 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 arithmeticPriorité des opérateurs spéciaux
Les opérateurs spéciaux comme %%, %/% et %in% ont une priorité supérieure à celle de + et -, mais inférieure à celle de ^. Une mauvaise compréhension de cette règle entraîne des erreurs difficiles à détecter.
# %% 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) = 2Comparaisons avant opérateurs logiques
Les opérateurs de comparaison (<, >, ==, etc.) sont évalués avant les opérateurs logiques (!, &, |). Ainsi, x > 0 & y < 10 fonctionne comme prévu sans parenthèses supplémentaires.
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), '
')Erreur subtile de priorité n° 1
Une erreur fréquente consiste à oublier que ! a une priorité inférieure à celle de la comparaison : !x == y est interprété comme (!x) == y, et non comme !(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)Erreur subtile de priorité n° 2
Autre erreur difficile à détecter : -1:5 crée la séquence -1, 0, 1, 2, 3, 4, 5 — le signe moins unaire s’applique uniquement à 1, et non à l’ensemble de l’intervalle. Pour obtenir un intervalle commençant par un nombre négatif, utilisez des parenthèses.
# 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 explicitUtiliser des parenthèses pour plus de clarté
Même lorsque les parenthèses ne sont pas strictement nécessaires, leur utilisation rend le code plus facile à lire et moins sujet aux erreurs. Ne vous fiez jamais à la mémorisation de la table complète des priorités : utilisez des parenthèses pour exprimer clairement votre intention.
# 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, '
')Affectation dans les expressions
L’affectation (<-) a une priorité très faible — inférieure à celle de la plupart des opérateurs. Vous pouvez donc affecter le résultat de toute expression complexe en une seule ligne, mais cela signifie également qu’une affectation dans une expression peut se comporter de manière inattendue.
# <- 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)En pratique : éviter les erreurs de priorité
Voici une stratégie pratique pour écrire des expressions complexes correctes : décomposez les expressions longues en étapes intermédiaires nommées. Cela facilite également le débogage, car vous pouvez examiner chaque étape.
# 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), '
')Priorité avec AND/OR logiques
& (AND) a une priorité supérieure à celle de | (OR). Ainsi, A | B & C est évalué comme A | (B & C). Utilisez toujours des parenthèses lorsque vous combinez AND et OR afin d’éviter les erreurs logiques difficiles à détecter.
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 = FALSEVérification rapide
À quelle valeur -3 ^ 2 est-il évalué dans R ?
Récapitulatif : priorité des opérateurs
Excellent ! Voici les points essentiels à retenir de cette leçon :
- Ordre des priorités (de la plus élevée à la plus faible) :
^,-unaire,:,%%/%/%*%%in%,*/,+-, comparaisons,!,&,|, affectation -2^2 = -4, car^est prioritaire sur le signe moins unaire — utilisez(-2)^2pour obtenir 41:n+1signifie(1:n)+1— utilisez1:(n+1)si vous souhaitez un intervalle plus long&est plus prioritaire que|— placez entre parenthèses les expressions logiques combinant AND et OR- En cas de doute, utilisez des parenthèses pour expliciter votre intention et éviter les erreurs
# 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, '
')Questions Fréquemment Posées
La leçon « Priorité des opérateurs et expressions complexes » est-elle gratuite ?
Oui — le texte complet de « Priorité des opérateurs et expressions complexes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Priorité des opérateurs et expressions complexes » ?
Comprenez l’ordre d’évaluation et écrivez des expressions complexes en toute sécurité. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer R Academy ?
Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Priorité des opérateurs et expressions complexes » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon R Academy ?
Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Opérateurs arithmétiques et de comparaison
- Opérateurs logiques et logique booléenne
- Affectation et opérateurs spéciaux
- Priorité des opérateurs et expressions complexes