Commentaires, style et lisibilité
Écrivez du code R propre et documenté en suivant le guide de style tidyverse.
Commentaires, style et lisibilité est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Commentaires sur une seule ligne avec #
Dans R, le caractère # commence un commentaire. Tout ce qui suit # jusqu’à la fin de la ligne est ignoré par l’interpréteur. Les commentaires sont destinés aux humains : expliquez pourquoi, et pas seulement quoi.
# This is a comment — R ignores it completely
x <- 42 # inline comment after code
# Bad comment (states the obvious):
y <- y + 1 # add 1 to y
# Good comment (explains intent):
y <- y + 1 # shift index to 1-based for output display
cat('x =', x)En-têtes de section avec ------
Une convention R largement adoptée consiste à créer des en-têtes de section en ajoutant au moins quatre tirets, signes égal ou dièses après le texte du commentaire. RStudio les reconnaît et les ajoute au plan du document pour faciliter la navigation.
# Data Loading -------------------------------------------------------
# This section loads raw CSV files from the data/ folder
# Data Cleaning =======================================================
# Remove duplicates and fix missing values
# Modeling ############################################################
# Fit linear model and evaluate
cat('Section headers improve navigation')Convention de nommage snake_case
Le guide de style tidyverse recommande snake_case pour tous les noms d’objets : des mots en minuscules séparés par des traits de soulignement. Pour rester cohérent, évitez les points, qui ressemblent à des appels de méthode dans d’autres langages, ainsi que camelCase.
# Good: snake_case
user_age <- 25
monthly_revenue <- 15000
calculate_mean <- function(x) mean(x)
# Avoid: dots in names (looks like OOP method calls)
user.age <- 25 # confusing
# Avoid: camelCase (inconsistent with tidyverse)
userAge <- 25
# Avoid: ALL_CAPS (reserved for true constants by convention)
MAX_RETRIES <- 3 # acceptable for config constants only
cat('snake_case wins')Espaces autour des opérateurs
Mettez toujours des espaces autour des opérateurs d’affectation et de comparaison. Cela améliore considérablement la lisibilité. La seule exception concerne les listes d’arguments de fonctions, où = associe les noms aux arguments.
# Good: spaces around <- and operators
x <- 10
y <- x + 5
result <- x * y - 2
is_valid <- x > 0 & y < 100
# Bad: cramped
x<-10
y<-x+5
# Function arguments: = without extra spaces is fine
mean(x = c(1, 2, 3), na.rm = TRUE)
# Comparison operators also need spaces
if (x > 0) cat('positive')
if (x >= 0 & y <= 100) cat('in range')Utilisez <- et non = pour l’affectation
Bien que R autorise = pour l’affectation au niveau supérieur, la convention fortement établie dans la communauté consiste à utiliser <- pour affecter des objets et à réserver = exclusivement aux valeurs des arguments de fonctions. Cette distinction rend le code beaucoup plus facile à lire au premier coup d’œil.
# Correct: <- for assignment
name <- 'Alice'
score <- 95.5
results <- c(1, 2, 3)
# Correct: = inside function calls
round(3.14159, digits = 2)
read.csv('data.csv', header = TRUE, sep = ',')
# Avoid: = for top-level assignment
# name = 'Alice' <- works but not idiomatic
cat('Assignment convention:', name, score)La limite de 80 caractères par ligne
Limiter les lignes à 80 caractères garantit que le code reste lisible dans les éditeurs à volets, les pages imprimées et les outils de revue de code. Dans RStudio, vous pouvez afficher un repère de marge à la colonne 80 via Outils → Options globales → Code → Affichage.
# Bad: one very long line (hard to read)
result <- some_function(argument_one = 'value', argument_two = 100, argument_three = TRUE, argument_four = 'long_string')
# Good: break at commas, indent continuation
result <- some_function(
argument_one = 'value',
argument_two = 100,
argument_three = TRUE,
argument_four = 'long_string'
)
cat('Readable at 80 chars')Pas de point-virgule
Contrairement à JavaScript ou au C, R n’exige pas de point-virgule à la fin des instructions. Les points-virgules peuvent servir à placer plusieurs instructions sur une même ligne, mais le guide de style préconise : une instruction par ligne, sans point-virgule.
# Bad: semicolons and multiple statements per line
x <- 1; y <- 2; z <- x + y
# Good: one statement per line
x <- 1
y <- 2
z <- x + y
# The semicolon form is only acceptable in very short
# interactive throwaway code, never in scripts
cat('z =', z)Des noms de variables lisibles
Choisissez des noms descriptifs sans être excessivement longs. Une bonne règle : si, six mois plus tard, vous devez réfléchir plus d’une seconde pour comprendre un nom de variable, c’est qu’il est trop court ou trop énigmatique.
# Too cryptic:
d <- read.csv('data.csv')
tmp <- d[d$v1 > 0, ]
r <- lm(v2 ~ v1, data = tmp)
# Good names:
sales_data <- read.csv('data.csv')
positive_rows <- sales_data[sales_data$revenue > 0, ]
revenue_model <- lm(profit ~ revenue, data = positive_rows)
# Avoid abbreviations that are not universally understood:
# n_obs is fine (number of observations)
# nrv is not (nobody knows what this is)
cat('Names tell the story')Accolades et indentation
Le guide de style tidyverse précise que l’accolade ouvrante { doit être sur la même ligne et l’accolade fermante } sur sa propre ligne. Utilisez une indentation de 2 espaces, et non des tabulations. Une indentation cohérente est essentielle pour lire une logique imbriquée.
# Good style: brace on same line, 2-space indent
if (x > 0) {
cat('positive\n')
} else {
cat('non-positive\n')
}
# Good function definition:
calculate_bmi <- function(weight_kg, height_m) {
bmi <- weight_kg / height_m^2
round(bmi, 1)
}
cat('BMI:', calculate_bmi(70, 1.75))Espacement à l’intérieur des crochets et autour des virgules
Ajoutez un espace après chaque virgule, comme en français écrit, mais aucun espace avant une virgule ni immédiatement à l’intérieur des crochets. Cela reprend la notation mathématique et facilite la lecture de l’indexation.
# Good: space after comma, not before
x <- c(1, 2, 3, 4, 5)
m <- matrix(1:9, nrow = 3, ncol = 3)
# Subsetting: no space before [ or inside []
first_row <- m[1, ] # good
value <- m[2, 3] # good
# Bad:
# c(1,2,3) <- no space after comma
# m[ 1, ] <- space after [
# m[1 , ] <- space before comma
cat('Spacing is consistent')Utiliser styler et lintr
Deux outils automatisent l’application des règles de style dans R. styler reformate votre code pour respecter le guide de style tidyverse. lintr vérifie statiquement le style et les erreurs potentielles de votre code sans l’exécuter. Tous deux s’intègrent à RStudio.
# styler: reformat a file automatically
# install.packages('styler')
# styler::style_file('my_script.R')
# styler: reformat the whole project
# styler::style_dir('R/')
# lintr: check for style and potential bugs
# install.packages('lintr')
# lintr::lint('my_script.R')
# lintr reports issues like:
# line 10: [object_name_linter] Variable 'myVar' should use snake_case
# line 15: [spaces_around_ops_linter] No space before '<-'
cat('Style tools: styler + lintr')Vérification rapide
Selon le guide de style tidyverse, quelle est la bonne façon d’écrire une instruction d’affectation en R ?
Style et lisibilité — points essentiels
Un code R bien mis en forme est professionnel, facile à maintenir et adapté au travail collaboratif :
#pour les commentaires : expliquez pourquoi, et pas seulement quoi- En-têtes de section avec
------ou======pour faciliter la navigation snake_casepour tous les noms d’objets et de fonctions- Espaces autour de
<-,+,==, etc. - Utilisez
<-pour l’affectation et=uniquement dans les arguments de fonctions - 80 caractères maximum par ligne : répartissez les appels longs sur plusieurs lignes
- Pas de point-virgule : une instruction par ligne
- Indentation de 2 espaces, accolade ouvrante
{sur la même ligne - Utilisez styler pour le formatage automatique et lintr pour détecter les problèmes
# Putting it all together:
# Calculate summary statistics ----------------------------------------
calculate_summary <- function(values, remove_na = TRUE) {
cleaned <- values[!is.na(values)]
list(
mean = mean(cleaned),
median = median(cleaned),
sd = sd(cleaned)
)
}
test_scores <- c(85, 90, NA, 78, 92, 88)
stats <- calculate_summary(test_scores)
cat('Mean:', stats$mean, '\n')
cat('SD: ', stats$sd)Questions Fréquemment Posées
La leçon « Commentaires, style et lisibilité » est-elle gratuite ?
Oui — le texte complet de « Commentaires, style et lisibilité » 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 « Commentaires, style et lisibilité » ?
Écrivez du code R propre et documenté en suivant le guide de style tidyverse. 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 2 sur 4.
Combien de temps prend la leçon « Commentaires, style et lisibilité » ?
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
- Utiliser source() pour charger des scripts
- Commentaires, style et lisibilité
- Répertoires de travail et chemins de fichiers
- Projets R et gestion de l’espace de travail