Options d’exécution du code dans Quarto : echo, eval, output, warning et code-fold

Q: Comment masquer le code mais conserver la sortie dans Quarto ?

Définissez #| echo: false sur le bloc (ou echo: false sous execute: dans le YAML pour tout le document). Le code est masqué et son résultat — un graphique, un tableau, une valeur — s’affiche toujours. Pour masquer le code et la sortie, utilisez plutôt #| include: false.

Q: Quelle est la différence entre echo, eval, output et include ?

echo contrôle si la source est affichée, eval si le code s’exécute, et output si le résultat est affiché — trois interrupteurs indépendants. include est l’option fourre-tout : include: false exécute le bloc mais n’affiche rien du tout (ni code, ni sortie), ce qui est le motif standard du bloc de configuration.

Q: Comment empêcher les avertissements et les messages d’apparaître dans mon rapport ?

Définissez warning: false et message: false — sur un seul bloc avec #|, ou à l’échelle du document sous execute: dans le YAML. warning coupe les avertissements R ; message coupe la sortie de message() comme les bannières de démarrage des packages.

Q: Comment définir une option d’exécution pour tout le document ?

Placez-la sous une clé execute: dans l’en-tête YAML — par exemple echo: false imbriqué sous execute:. Elle devient la valeur par défaut de chaque bloc, et toute option #| par bloc la surcharge. Les options de figure et d’affichage du code comme code-fold se placent plutôt sous format: html:.

Q: Comment rendre le code repliable dans Quarto ?

Définissez #| code-fold: true sur le bloc, ou code-fold: true sous format: html: pour tout le document. Le code est rendu à l’intérieur d’un bouton « Afficher le code » que le lecteur peut déployer ; code-summary change l’étiquette du bouton, et code-fold: show le rend déjà déployé.

Contrôlez ce qui s’exécute et ce qui s’affiche — par bloc et pour tout le document

Apprenez à contrôler l’exécution du code dans Quarto — affichez ou masquez le code avec echo, exécutez-le ou ignorez-le avec eval, conservez ou supprimez la sortie, faites taire les avertissements et les messages, et repliez le code avec code-fold. Définissez les options par bloc ou pour tout le document.

Date de publication

8 juillet 2026

Modifié

9 juillet 2026

Points clés

Les options de bloc commencent par #| en haut d’une cellule de code (#| echo: false) ; les mêmes noms se placent sous execute: dans le YAML pour définir une valeur par défaut à l’échelle du document.
echo affiche ou masque la source, eval l’exécute ou l’ignore, output conserve ou supprime le résultat — trois interrupteurs indépendants que vous combinez pour obtenir exactement ce qui apparaît.
warning: false et message: false font taire les avertissements et le bavardage des packages qui encombrent un rapport ; include: false masque entièrement un bloc tout en l’exécutant (le motif du bloc de configuration).
code-fold: true replie le code derrière un bouton « Afficher le code » — le lecteur voit d’abord le résultat et déploie la source à la demande.
Tout ici est auto-démonstratif : l’effet de chaque option est rendu juste sous la source exacte qui l’a produit — copiez n’importe quel bloc et exécutez-le.

Scatter plot of car weight against miles per gallon with a smooth downward azure trend line, rendered from a Quarto code chunk whose source is hidden. — Figure 1: A figure rendered from a Quarto chunk with `echo: false` — the code that drew it is hidden, so the report shows only the result.

Introduction

Un document Quarto exécute votre code et insère les résultats dans la page. Mais un rapport veut rarement afficher chaque ligne de code, chaque avertissement et chaque impression intermédiaire. Les options d’exécution vous permettent de décider, cellule par cellule, ce qui apparaît réellement : le code, le résultat, les deux, ou ni l’un ni l’autre.

Il y a deux endroits où les définir. Sur une seule cellule, une option est une ligne de commentaire en haut du bloc préfixée par #| (le « hash-pipe »). À l’échelle du document, la même option se place sous une clé execute: dans l’en-tête YAML, où elle devient la valeur par défaut de chaque bloc. Une option par bloc l’emporte toujours sur la valeur par défaut du document : vous définissez donc une valeur par défaut raisonnable une fois et surchargez les exceptions.

Cette leçon est auto-démonstrative : chaque effet ci-dessous a été produit par la source exacte affichée juste au-dessus. Lisez la source, puis regardez ce que Quarto a rendu. La référence complète est la documentation des options d’exécution de Quarto ; c’est le sous-ensemble pratique auquel vous recourez pour chaque rapport.

---
title: "My report"
execute:
  echo: false      # hide code everywhere by default
  warning: false   # keep warnings out of the report
jupyter: python3
---

Ce YAML définit une valeur par défaut à l’échelle du document ; les sections ci-dessous montrent chaque option en action et comment la surcharger sur une seule cellule.

Afficher ou masquer le code avec `echo`

echo contrôle si la source apparaît. Avec la valeur par défaut echo: true, le lecteur voit le code et sa sortie. Passez à echo: false et le code est masqué — la sortie (un graphique, un tableau, une valeur) s’affiche toujours. C’est l’interrupteur que vous utilisez le plus dans un rapport finalisé : gardez les figures, supprimez le code.

Voici un bloc qui dessine un graphique avec le code masqué. D’abord la source :

```{r}
#| echo: false
#| fig-alt: "Scatter plot of engine displacement against miles per gallon."
library(ggplot2)
ggplot(mtcars, aes(disp, mpg)) +
  geom_point(color = "#3a86d4", size = 2.5) +
  labs(x = "Displacement (cu. in.)", y = "Miles per gallon") +
  theme_minimal()
```

Et le résultat rendu — remarquez que le graphique apparaît mais pas le code qui l’a dessiné :

Scatter plot of engine displacement on the x-axis against miles per gallon on the y-axis; points trend downward as displacement rises.

Pour masquer le code de tout le document, définissez echo: false sous execute: dans le YAML (comme dans l’introduction), puis ajoutez #| echo: true sur les quelques blocs pédagogiques où vous voulez afficher la source.

Exécuter ou ignorer le code avec `eval`

eval décide si le code s’exécute réellement. La valeur par défaut eval: true exécute le bloc. Passez à eval: false et Quarto affiche le code mais ne l’exécute pas — il n’y a donc aucune sortie. C’est ainsi que vous affichez une commande que vous ne voulez pas exécuter au moment du rendu : un appel install.packages(), une tâche de longue durée, ou une ligne qui accéderait au réseau.

```{r}
#| eval: false
install.packages("gt")
```

Une fois rendu, le code est affiché pour que le lecteur puisse le copier, mais rien ne s’est exécuté et rien n’a été installé :

install.packages("gt")

eval: false affiche quand même le code (sauf si vous définissez aussi echo: false), ce qui est exactement ce que vous voulez pour une instruction du type « voici la commande, exécutez-la vous-même ».

Conserver ou supprimer le résultat avec `output`

output contrôle le résultat — les valeurs imprimées, les tableaux et les figures — indépendamment du code. Avec output: false, le bloc s’exécute et le code s’affiche, mais le résultat est supprimé. Utilisez-le lorsqu’une étape a un effet de bord que vous voulez (un ajustement, une écriture sur disque) mais une impression que vous ne voulez pas.

```{r}
#| output: false
summary(mtcars$mpg)
```

Le code apparaît et summary() s’est réellement exécuté, mais sa sortie est supprimée :

summary(mtcars$mpg)

output accepte aussi asis, qui transmet le résultat tel quel en Markdown brut au lieu de l’envelopper dans le bloc de sortie habituel de Quarto — utile quand votre code génère du Markdown. Ici, un bloc émet du texte en gras avec cat() et output: asis le rend comme du vrai Markdown plutôt que comme un résultat de code :

```{r}
#| output: asis
#| echo: false
cat("**This bold line was generated by R code.**")
```

This bold line was generated by R code.

Combinez les trois interrupteurs pour obtenir n’importe quel comportement : echo: true, eval: false affiche du code qui ne s’exécute jamais ; echo: false, output: true affiche un résultat sans code (la figure d’en-tête en haut de cette page) ; echo: false, output: false — voir include, ci-dessous — masque tout.

Faire taire les avertissements et les messages

Le code d’analyse est bruyant. L’impression d’un modèle, la bannière de démarrage d’un package, un avertissement « NaNs produced » — rien de tout cela n’a sa place dans un rapport propre. Deux options coupent le bruit : warning pour les avertissements et message pour les messages (le bavardage que les fonctions R impriment via message(), y compris les bannières de chargement de packages).

Ce document définit les deux à false dans son propre en-tête, de sorte que les avertissements et les messages sont masqués partout. Pour faire apparaître un avertissement sur un seul bloc, surchargez avec #| warning: true. Ici, un bloc déclenche délibérément un avertissement :

```{r}
#| warning: true
sqrt(-1)
```

Avec warning: true, l’avertissement s’affiche en ligne sous le résultat :

sqrt(-1)

Warning in sqrt(-1): Production de NaN

[1] NaN

message fonctionne de la même manière pour la sortie de message(). L’usage le plus courant est l’inverse du précédent — vous définissez message: false (comme le fait ce document) pour que la bannière de démarrage d’un appel library() n’atteigne jamais la page :

```{r}
#| message: true
message("Model converged in 3 iterations.")
```

message("Model converged in 3 iterations.")

Model converged in 3 iterations.

Dans un vrai rapport, vous définissez warning: false et message: false à l’échelle du document et vous les oubliez — la référence des options d’exécution liste l’ensemble complet, y compris error: true pour laisser un bloc qui lève une erreur rendre l’erreur au lieu d’interrompre tout le rendu.

Masquer entièrement un bloc avec `include`

include: false est l’option fourre-tout : le bloc s’exécute, mais ni le code ni aucune sortie n’apparaît. C’est le motif du bloc de configuration — charger les packages, définir les options, lire les données — réalisé silencieusement en haut d’un document pour que le lecteur ne voie jamais la tuyauterie.

```{r}
#| include: false
library(ggplot2)
options(digits = 3)
```

Le bloc ci-dessous utilise include: false ; il s’est exécuté, mais rien n’a été rendu — il n’y a tout simplement aucune trace sur la page :

Utilisez include: false pour le travail préparatoire invisible et echo: false lorsque vous voulez tout de même le résultat (une figure, un tableau) mais pas le code.

Replier le code avec `code-fold`

Parfois, vous voulez que le code soit disponible mais discret — visible à la demande, masqué par défaut. code-fold: true rend la source à l’intérieur d’un bouton repliable « Afficher le code », de sorte que le lecteur voit d’abord le résultat et ne déploie le code que s’il s’intéresse à la façon dont il a été produit. code-summary définit l’étiquette du bouton. C’est une option d’affichage HTML (voir la documentation du code HTML de Quarto) : contrairement à echo, elle garde donc le code à un clic plutôt que de le supprimer.

```{r}
#| code-fold: true
#| code-summary: "Show the plot code"
#| fig-alt: "Histogram of highway fuel economy."
library(ggplot2)
ggplot(mtcars, aes(mpg)) +
  geom_histogram(fill = "#3a86d4", bins = 10, color = "white") +
  labs(x = "Miles per gallon", y = "Count") +
  theme_minimal()
```

Une fois rendu, le graphique s’affiche immédiatement et le code se trouve derrière le bouton au-dessus — cliquez sur « Show the plot code » pour le déployer :

Show the plot code

library(ggplot2)
ggplot(mtcars, aes(mpg)) +
  geom_histogram(fill = "#3a86d4", bins = 10, color = "white") +
  labs(x = "Miles per gallon", y = "Count") +
  theme_minimal()

Histogram of miles per gallon across the mtcars dataset, with ten azure bars showing the distribution centred near 20 MPG.

Définissez code-fold: true une fois sous format: html: dans le YAML pour replier chaque bloc du document, et code-fold: show pour rendre les boutons déjà déployés.

Afficher les délimiteurs avec `echo: fenced`

Lorsque vous enseignez Quarto lui-même, vous avez souvent besoin que le lecteur voie la cellule de code entière — la clôture ```{r} et les options #| incluses, pas seulement le R à l’intérieur. echo: fenced fait exactement cela : il imprime les délimiteurs et les options propres au bloc en plus de la source, et exécute quand même le code. Le bloc ci-dessous applique echo: fenced à lui-même, de sorte que sa forme rendue montre sa propre clôture :

```{r}
#| label: demo-fenced
1 + 1
```

[1] 2

C’est ainsi que les blocs « source » tout au long de cette série restent honnêtes — la clôture que vous lisez est la clôture qui s’est exécutée. (L’alternative, pour une cellule que vous voulez afficher mais sans l’exécuter, consiste à échapper les accolades sous la forme ```{r}, que Quarto imprime littéralement comme ```{r} sans l’exécuter — le motif utilisé pour les exemples de source ci-dessus.)

Options à l’échelle du document et options avancées

Quelques options méritent d’être connues pour un projet plus vaste.

execute: dans le YAML définit la valeur par défaut de chaque bloc (echo, eval, warning, message, output, error, include), surchargeable par bloc.
knitr: opts_chunk: définit les options de bloc knitr natives à l’échelle du document — par exemple collapse: true pour fusionner le code et la sortie en un seul bloc, ou comment: "#>" pour changer le préfixe de sortie.
keep-md: true conserve le fichier Markdown intermédiaire produit par l’exécution du code — pratique pour déboguer un rendu.

Il s’agit d’une référence statique plutôt que de quelque chose à rendre, les voici donc en YAML :

---
title: "My report"
format: html
execute:
  echo: false
  warning: false
knitr:
  opts_chunk:
    collapse: true
    comment: "#>"
keep-md: true
---

Les options propres aux figures — fig-width, fig-height, fig-cap, fig-alt — sont aussi des options d’exécution, mais elles ont une leçon à elles : voir Les figures dans Quarto.

Les options en un coup d’œil

Les options d’exécution essentielles, chacune définie avec #| sur un bloc ou sous execute: dans le YAML :

Option	Ce qu’elle contrôle	Usage courant
`echo`	Si le code source est affiché	`false` pour masquer le code dans un rapport ; `fenced` pour afficher aussi la clôture
`eval`	Si le code est exécuté	`false` pour afficher une commande sans l’exécuter
`output`	Si le résultat est affiché	`false` pour conserver un effet de bord mais supprimer l’impression ; `asis` pour du Markdown brut
`warning`	Si les avertissements apparaissent	`false` à l’échelle du document pour garder des rapports propres
`message`	Si les messages apparaissent	`false` pour masquer les bannières de démarrage des packages
`error`	Si une erreur est rendue au lieu d’interrompre	`true` pour documenter une erreur délibérée
`include`	Fourre-tout : afficher quoi que ce soit	`false` pour un bloc de configuration silencieux qui s’exécute quand même

Problèmes fréquents

Définir echo: false laisse quand même un avertissement ou une bannière de démarrage sur la page. echo ne masque que la source. Les avertissements viennent de warning, et le chargement des packages ainsi que le reste du bavardage de message() viennent de message. Définissez warning: false et message: false (généralement à l’échelle du document sous execute:) pour les faire taire.

Un bloc avec eval: false affiche le code mais le bloc suivant qui en dépend échoue. eval: false signifie que le code ne s’est jamais exécuté, donc tout objet qu’il aurait créé n’existe pas. Soit vous exécutez le bloc (eval: true), soit vous rendez le bloc en aval autonome. N’utilisez eval: false que pour du code que vous ne voulez vraiment pas exécuter au moment du rendu.

include: false a masqué le bloc mais la figure que je voulais a disparu elle aussi. include: false supprime tout, sortie comprise. Si vous voulez la figure mais pas le code, utilisez plutôt echo: false — cela conserve le résultat et ne masque que la source.

Questions fréquentes

Comment masquer le code mais conserver la sortie dans Quarto ?

Définissez #| echo: false sur le bloc (ou echo: false sous execute: dans le YAML pour tout le document). Le code est masqué et son résultat — un graphique, un tableau, une valeur — s’affiche toujours. Pour masquer le code et la sortie, utilisez plutôt #| include: false.

Quelle est la différence entre echo, eval, output et include ?

echo contrôle si la source est affichée, eval si le code s’exécute, et output si le résultat est affiché — trois interrupteurs indépendants. include est l’option fourre-tout : include: false exécute le bloc mais n’affiche rien du tout (ni code, ni sortie), ce qui est le motif standard du bloc de configuration.

Comment empêcher les avertissements et les messages d’apparaître dans mon rapport ?

Définissez warning: false et message: false — sur un seul bloc avec #|, ou à l’échelle du document sous execute: dans le YAML. warning coupe les avertissements R ; message coupe la sortie de message() comme les bannières de démarrage des packages.

Comment définir une option d’exécution pour tout le document ?

Placez-la sous une clé execute: dans l’en-tête YAML — par exemple echo: false imbriqué sous execute:. Elle devient la valeur par défaut de chaque bloc, et toute option #| par bloc la surcharge. Les options de figure et d’affichage du code comme code-fold se placent plutôt sous format: html:.

Comment rendre le code repliable dans Quarto ?

Définissez #| code-fold: true sur le bloc, ou code-fold: true sous format: html: pour tout le document. Le code est rendu à l’intérieur d’un bouton « Afficher le code » que le lecteur peut déployer ; code-summary change l’étiquette du bouton, et code-fold: show le rend déjà déployé.

Testez vos connaissances

Exercice 1. Vous rédigez un rapport. Vous voulez que le graphique d’un bloc apparaisse mais que son code reste masqué, et vous voulez aussi qu’aucun avertissement n’apparaisse nulle part dans le document. Écrivez le YAML au niveau du document et les options de bloc qui réalisent cela.

Indice

Deux niveaux différents font le travail : une option va dans le bloc execute: du YAML (s’applique partout), et une va sur le bloc (masque uniquement ce code). Rappelez-vous que echo masque la source mais conserve la sortie.

Solution

Valeur par défaut à l’échelle du document dans le YAML :

---
title: "My report"
execute:
  warning: false
---

Et sur le bloc, masquez le code tout en conservant le graphique :

```{r}
#| echo: false
#| fig-alt: "A descriptive alt text for the plot."
library(ggplot2)
ggplot(mtcars, aes(wt, mpg)) +
  geom_point(color = "#3a86d4") +
  theme_minimal()
```

warning: false dans execute: fait taire les avertissements dans tout le document ; #| echo: false masque la source de ce seul bloc pendant que son graphique s’affiche toujours.

Exercice 2. Vous voulez montrer à un lecteur une commande install.packages() dans le document sans l’exécuter au moment du rendu. Quelle option définissez-vous, et que voit le lecteur ?

Solution

Définissez #| eval: false :

```{r}
#| eval: false
install.packages("gt")
```

Le code est affiché (pour que le lecteur puisse le copier) mais ne s’exécute jamais, donc rien n’est installé et il n’y a aucune sortie. eval: false affiche quand même le code — ajoutez aussi #| echo: false uniquement si vous voulez également le masquer.

Vérification rapide

Vous définissez #| echo: false sur un bloc qui charge un package et produit un message de démarrage, en vous attendant à une page propre — mais la bannière de démarrage s’affiche quand même. Pourquoi ?

A. echo: false a été surchargé par la valeur par défaut du document B. echo ne masque que le code source ; le message nécessite message: false C. Les bannières de package ne peuvent jamais être masquées

Afficher la réponse

B. echo contrôle uniquement si la source est affichée. La bannière de démarrage d’un package est un message, elle est donc régie par message — définissez #| message: false (ou message: false sous execute: à l’échelle du document) pour la faire taire.

Conclusion

Les options d’exécution se résument à trois interrupteurs indépendants plus quelques commodités : echo pour le code, eval pour savoir s’il s’exécute, output pour le résultat — combinez-les pour afficher exactement ce dont un rapport a besoin. Ajoutez warning: false et message: false pour garder la page propre, include: false pour une configuration silencieuse, et code-fold: true pour ranger le code derrière un bouton. Définissez les valeurs par défaut une fois sous execute: dans le YAML, surchargez les exceptions par bloc, et laissez Quarto garder le code et les résultats synchronisés.

Leçons connexes

Les figures dans Quarto — les options d’exécution propres aux figures (fig-cap, fig-alt, fig-width, mise en page) qui accompagnent celles présentées ici. · Les tableaux dans Quarto — mettez en forme les résultats calculés sous forme de tableaux propres et référencés. · Des notebooks aux rapports reproductibles — le flux de travail documentaire dans lequel ces options s’inscrivent. · Choisir un IDE — RStudio et Positron offrent la boucle de rendu-et-prévisualisation la plus rapide pour itérer sur ces options.
Pour aller plus loin : Créer des documents avec Quarto — la série complète. · Science computationnelle et IA — le pilier.

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

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché, exécuté au moment de la compilation — copiez n’importe quel bloc et exécutez-le pour reproduire ces résultats. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Options d’exécution du code dans Quarto : echo, eval, output,
    warning et code-fold},
  date = {2026-07-08},
  url = {https://www.datanovia.com/learn/programming/quarto/execution-options},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Options d’exécution du code dans Quarto : echo, eval, output, warning et code-fold.” 2026. July 8. https://www.datanovia.com/learn/programming/quarto/execution-options.