Flux de contrôle en R : if, else, boucles for et while

Q: Comment écrire une instruction if-else en R ?

Utilisez if (condition) { … } else { … }, et enchaînez else if pour plus de chemins : if (x > 0) "pos" else if (x < 0) "neg" else "zero". La condition doit être une valeur TRUE/FALSE unique. Pour décider pour chaque élément d’un vecteur à la place, utilisez ifelse().

Q: Quelle est la différence entre if et ifelse en R ?

if est une instruction de contrôle : elle prend une valeur TRUE/FALSE et choisit quel bloc de code s’exécute. ifelse(test, yes, no) est une fonction vectorisée : elle prend tout un vecteur logique et renvoie yes ou no pour chaque élément. Utilisez if pour brancher le flux de votre programme ; utilisez ifelse() pour calculer une valeur par élément d’un vecteur.

Q: Comment écrire une boucle for en R ?

for (item in sequence) { … } exécute le corps une fois par élément : for (n in 1:3) print(n). Bouclez sur seq_along(x) quand vous avez besoin de l’indice en plus de la valeur. Si la boucle construit un résultat, préallouez le conteneur (numeric(n)) et remplissez par indice plutôt que de le faire grandir.

Q: Comment écrire une boucle while en R ?

while (condition) { … } répète tant que la condition est TRUE. Initialisez un compteur, faites le travail, et mettez à jour le compteur à l’intérieur de la boucle pour qu’il finisse par se rapprocher de FALSE — sinon elle tourne indéfiniment. Utilisez while quand vous ne connaissez pas le nombre d’itérations à l’avance ; utilisez for quand vous le connaissez.

Q: Quand faut-il utiliser une boucle plutôt que la vectorisation en R ?

Privilégiez les opérations vectorisées : v^2, x + y, et des fonctions comme ifelse()/rowSums() opèrent sur tout un vecteur d’un coup — plus courtes et bien plus rapides qu’une boucle. Quand la logique par élément n’est pas une fonction vectorisée intégrée, utilisez la famille apply (sapply/lapply). N’écrivez une boucle for/while explicite que lorsque chaque étape dépend de la précédente (accumulation d’état, convergence) ou que vous faites des effets de bord comme afficher ou écrire des fichiers.

Brancher avec if/else, répéter avec for/while/repeat — et quand vectoriser à la place

Flux de contrôle en R : if / else if / else, le ifelse() vectorisé, les boucles for, while et repeat avec break/next, et switch(). Plus la règle qui compte le plus — quand sauter la boucle et laisser les opérations vectorisées de R ou la famille apply faire le travail.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

Points clés

if / else if / else choisit un chemin à partir d’une condition TRUE/FALSE unique.
ifelse(test, yes, no) est l’équivalent vectorisé — il décide élément par élément sur tout un vecteur.
for répète sur une séquence ; while répète jusqu’à ce qu’une condition bascule ; repeat boucle jusqu’à ce que vous fassiez break.
break sort d’une boucle prématurément, next passe à l’itération suivante ; switch() choisit parmi des cas nommés.
Privilégiez les opérations vectorisées ou la famille apply avant une boucle — en R, elles sont généralement plus rapides et plus claires.

Introduction

Le flux de contrôle, c’est la façon dont un script prend des décisions et répète du travail : « si le fichier existe, lis-le ; sinon arrête », ou « pour chaque groupe, calcule la moyenne ». R vous donne les outils habituels — if/else, for, while — plus deux choses qui échappent à ceux qui viennent d’autres langages : un ifelse() vectorisé qui décide sur tout un vecteur d’un coup, et une bonne raison d’éviter d’écrire des boucles en premier lieu.

Cette leçon couvre chaque construction, puis la partie qui sépare un R fluide d’un R traduit-depuis-Python : savoir quand ne pas boucler.

Brancher avec `if` / `else if` / `else`

if exécute un bloc quand une condition est TRUE ; else couvre le cas FALSE ; enchaînez else if pour plus de deux chemins.

x <- 7

if (x > 0) {
  "positive"
} else if (x < 0) {
  "negative"
} else {
  "zero"
}

[1] "positive"

La condition doit être une valeur TRUE/FALSE unique. Donnez à if un vecteur logique et R n’utilise que le premier élément (R 4.2+ moderne lève une erreur à la place) — c’est cette erreur que ifelse() ci-dessous permet d’éviter.

== vs = — le piège de l’affectation

Comparez avec == (deux égales) ; affectez avec <- ou =. Écrire if (x = 7) est une erreur de syntaxe, et x = 7 à l’intérieur d’une condition où vous vouliez dire x == 7 est un bug classique. Dans une condition, vous voulez presque toujours ==.

`ifelse()` — la branche vectorisée

Quand vous voulez décider pour chaque élément d’un vecteur, ne bouclez pas et n’utilisez pas if. ifelse(test, yes, no) évalue le test par élément et renvoie yes là où il est TRUE, no là où il est FALSE.

temps <- c(18, 25, 30, 12, 27)
ifelse(temps >= 25, "warm", "cool")

[1] "cool" "warm" "warm" "cool" "warm"

Un seul appel, tout le vecteur, sans boucle. C’est la façon idiomatique de recoder ou d’étiqueter un vecteur en R.

score <- c(82, 47, 91, 63)
ifelse(score >= 60, "pass", "fail")

[1] "pass" "fail" "pass" "pass"

Utilisez if pour une décision oui/non unique qui contrôle quel code s’exécute ; utilisez ifelse() pour calculer une valeur pour chaque élément d’un vecteur.

Boucles `for`

Une boucle for exécute son corps une fois pour chaque élément d’une séquence — un vecteur, une liste, ou seq_along(x) pour les indices.

for (n in c(2, 4, 6)) {
  print(n * 10)
}

[1] 20
[1] 40
[1] 60

Quand vous avez besoin à la fois de la position et de la valeur, bouclez sur seq_along() :

fruits <- c("apple", "pear", "plum")
for (i in seq_along(fruits)) {
  cat(i, "->", fruits[i], "\n")
}

1 -> apple 
2 -> pear 
3 -> plum

Si une boucle construit un résultat, créez d’abord le conteneur à sa taille complète, puis remplissez-le — faire grandir un vecteur avec c() dans la boucle le recopie à chaque itération et c’est lent.

squares <- numeric(5)            # pre-allocate
for (i in 1:5) squares[i] <- i^2 # fill in place
squares

[1]  1  4  9 16 25

`while` et `repeat`

Une boucle while répète tant que sa condition reste TRUE — utilisez-la quand vous ne connaissez pas le nombre d’itérations à l’avance.

counter <- 1
while (counter <= 4) {
  print(counter)
  counter <- counter + 1   # MUST move toward the exit, or it never stops
}

[1] 1
[1] 2
[1] 3
[1] 4

repeat boucle indéfiniment jusqu’à ce que vous en sortiez avec break — la boucle « jusqu’à » la plus explicite.

counter <- 1
repeat {
  print(counter)
  counter <- counter + 1
  if (counter > 4) break    # the exit condition
}

[1] 1
[1] 2
[1] 3
[1] 4

Chaque while/repeat a besoin de quelque chose à l’intérieur qui progresse vers la condition de sortie, sinon il tourne indéfiniment.

`break` et `next`

À l’intérieur de n’importe quelle boucle, break l’arrête immédiatement et next saute le reste de l’itération en cours.

for (n in 1:8) {
  if (n %% 2 == 0) next   # skip even numbers
  if (n > 5) break        # stop once we pass 5
  print(n)
}

[1] 1
[1] 3
[1] 5

Ceci affiche les nombres impairs jusqu’à 5 : next saute par-dessus les nombres pairs, break met fin à la boucle quand n dépasse 5.

`switch()` — choisir parmi des cas nommés

Quand vous écririez une longue chaîne de else if comparant une valeur à plusieurs options fixes, switch() est plus propre.

describe <- function(animal) {
  switch(animal,
    cat = "meow",
    dog = "woof",
    cow = "moo",
    "unknown animal"     # the unnamed last entry is the default
  )
}
c(describe("dog"), describe("cow"), describe("fox"))

[1] "woof"           "moo"            "unknown animal"

switch() compare le premier argument aux noms et renvoie la valeur correspondante ; l’entrée non nommée finale est le repli par défaut.

Quand NE PAS boucler — vectorisez à la place

C’est l’habitude la plus importante en R. La plupart des boucles sur un vecteur sont inutiles : l’arithmétique et les fonctions de R sont vectorisées, donc elles opèrent sur tout le vecteur d’un coup — plus courtes à écrire et bien plus rapides qu’une boucle écrite à la main.

v <- c(2, 4, 6, 8)

# The loop way (works, but verbose and slow)
out <- numeric(length(v))
for (i in seq_along(v)) out[i] <- v[i]^2

# The R way — vectorized, one line
v^2

[1]  4 16 36 64

identical(out, v^2)

[1] TRUE

Quand l’opération diffère réellement d’un élément à l’autre et n’est pas une fonction vectorisée intégrée, tournez-vous vers la famille apply (sapply, lapply, vapply, tapply) plutôt qu’une boucle manuelle — même intention, code plus clair, et pas de gestion d’indices fragile.

# Apply a function to each element without an explicit loop
sapply(1:5, function(i) i^2)

[1]  1  4  9 16 25

La règle : essayez d’abord une expression vectorisée ; si la logique par élément est réelle, utilisez la famille apply ; n’écrivez une boucle for/while explicite que lorsque chaque étape dépend de la précédente (accumulation d’état, convergence) ou que vous faites des effets de bord (afficher, écrire des fichiers).

Approfondir sapply/lapply/vapply/tapply ? Voyez la leçon dédiée la famille apply en R — la boîte à outils sans boucle qui remplace la plupart des boucles for.

Essayez en direct

Les blocs ci-dessus se sont exécutés à la compilation. Modifiez celui-ci et appuyez sur Run pour essayer le flux de contrôle par vous-même — il s’exécute dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Vous avez une boucle for qui vous semble lente ou maladroite ? Collez-la et demandez à Prova « peut-on vectoriser ça ? ». Elle réécrit la boucle en expression vectorisée ou en appel apply — et comme le runtime est juste là, vous exécutez les deux et confirmez qu’ils renvoient le même résultat avant de faire confiance à la réécriture. Demander à Prova →

Problèmes courants

if avertit ou échoue sur une condition vectorielle. if (x > 5) où x est un vecteur n’utilise que le premier élément — et R 4.2+ échoue carrément (the condition has length > 1). Si vous vouliez décider par élément, utilisez ifelse(x > 5, …, …) ; si vous vouliez « est-ce que l’un / tous le sont », enveloppez avec any() / all() : if (any(x > 5)).

== vs = dans une condition. La comparaison est == (deux égales). = est une affectation — if (x = 5) est une erreur de syntaxe, et un seul = là où vous vouliez == est un bug logique silencieux. Dans une condition, vous voulez presque toujours ==.

Une boucle qui fait grandir un vecteur est lente. out <- c(out, value) dans une boucle recopie tout le vecteur à chaque itération. Préallouez avec numeric(n) / vector("list", n) et remplissez par indice — ou, mieux, vectorisez le tout et sautez la boucle.

while / repeat ne s’arrête jamais. Le corps doit modifier quelque chose qui rapproche la condition de FALSE (ou atteindre un break). Si R se bloque, votre condition de sortie n’est jamais atteinte — vérifiez que le compteur est bien mis à jour à l’intérieur de la boucle.

Questions fréquentes

Comment écrire une instruction if-else en R ?

Utilisez if (condition) { … } else { … }, et enchaînez else if pour plus de chemins : if (x > 0) "pos" else if (x < 0) "neg" else "zero". La condition doit être une valeur TRUE/FALSE unique. Pour décider pour chaque élément d’un vecteur à la place, utilisez ifelse().

Quelle est la différence entre if et ifelse en R ?

if est une instruction de contrôle : elle prend une valeur TRUE/FALSE et choisit quel bloc de code s’exécute. ifelse(test, yes, no) est une fonction vectorisée : elle prend tout un vecteur logique et renvoie yes ou no pour chaque élément. Utilisez if pour brancher le flux de votre programme ; utilisez ifelse() pour calculer une valeur par élément d’un vecteur.

Comment écrire une boucle for en R ?

for (item in sequence) { … } exécute le corps une fois par élément : for (n in 1:3) print(n). Bouclez sur seq_along(x) quand vous avez besoin de l’indice en plus de la valeur. Si la boucle construit un résultat, préallouez le conteneur (numeric(n)) et remplissez par indice plutôt que de le faire grandir.

Comment écrire une boucle while en R ?

while (condition) { … } répète tant que la condition est TRUE. Initialisez un compteur, faites le travail, et mettez à jour le compteur à l’intérieur de la boucle pour qu’il finisse par se rapprocher de FALSE — sinon elle tourne indéfiniment. Utilisez while quand vous ne connaissez pas le nombre d’itérations à l’avance ; utilisez for quand vous le connaissez.

Quand faut-il utiliser une boucle plutôt que la vectorisation en R ?

Privilégiez les opérations vectorisées : v^2, x + y, et des fonctions comme ifelse()/rowSums() opèrent sur tout un vecteur d’un coup — plus courtes et bien plus rapides qu’une boucle. Quand la logique par élément n’est pas une fonction vectorisée intégrée, utilisez la famille apply (sapply/lapply). N’écrivez une boucle for/while explicite que lorsque chaque étape dépend de la précédente (accumulation d’état, convergence) ou que vous faites des effets de bord comme afficher ou écrire des fichiers.

Testez vos connaissances

Exercice : étiqueter, boucler et vectoriser

Étant donné le vecteur ci-dessous : (1) utilisez ifelse() pour étiqueter chaque valeur "big" si elle est >= 100, sinon "small" ; (2) écrivez une boucle for qui n’affiche que les valeurs supérieures à 50 (utilisez next pour sauter le reste) ; (3) remplacez la logique de la boucle par un seul sous-ensemble vectorisé.

vals <- c(120, 30, 80, 5, 200)

labels <- ifelse(vals >= 100, "big", "small")

for (v in vals) {
  if (v <= 50) next
  print(v)
}

big_vals <- vals[vals > 50]

list(labels = labels, big_vals = big_vals)

Vérification rapide : qui branche tout un vecteur ?

Vous voulez transformer c(18, 25, 30) en c("cool", "warm", "warm") en un seul appel. Lequel est correct ?

A. if (temps >= 25) "warm" else "cool" B. ifelse(temps >= 25, "warm", "cool") C. for (t in temps) if (t >= 25) "warm" else "cool"

Afficher la réponse

B. ifelse() est vectorisé — il renvoie un résultat pour chaque élément. A utilise if, qui ne prend qu’une seule condition (et échoue sur un vecteur de longueur 3 en R moderne). C boucle mais ne collecte ni ne renvoie jamais les résultats.

Conclusion

Le flux de contrôle en R, c’est if/else if/else pour une décision unique, ifelse() pour une décision par élément, et for/while/repeat (avec break/next) pour la répétition, plus switch() pour un appariement multi-voies propre. Mais l’habitude qui rend le code rapide et idiomatique, c’est de savoir quand sauter complètement la boucle : essayez d’abord une expression vectorisée, tournez-vous ensuite vers la famille apply, et n’écrivez une boucle explicite que lorsque chaque étape dépend vraiment de la précédente.

Leçons connexes

Vecteurs et types de données en R — les vecteurs sur lesquels vos conditions et boucles s’exécutent. · Indexation et sous-ensembles en R — le sous-ensemble par condition logique qui remplace souvent une boucle. · La famille apply en R — la boîte à outils sans boucle pour le travail par élément. · Écrire des fonctions en R — encapsulez la logique répétée plutôt que de copier-coller.
Aller plus loin : Fondations R — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Flux de contrôle en R : if, else, boucles for et while},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/r-foundations/control-flow},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Flux de contrôle en R : if, else, boucles for et while.” 2026. June 26. https://www.datanovia.com/learn/programming/r-foundations/control-flow.