Contrôles d’entrée Shiny : la référence complète des widgets en R

Q: Comment récupérer la valeur d’une entrée Shiny ?

Lisez-la dans le server comme input$ , où est l’inputId que vous avez donné au widget. Un curseur déclaré sliderInput("bins", …) se lit comme input$bins ; un selectInput("car", …) comme input$car. L’id doit correspondre exactement, casse comprise.

Q: Comment définir la valeur sélectionnée par défaut d’une entrée ?

Utilisez selected pour les entrées à choix (selectInput, radioButtons, checkboxGroupInput) et value pour les entrées texte, numériques, à curseur et de date. Pour les entrées à choix, selected doit être l’une des valeurs de choices — avec choices = c("Compact" = "compact") la valeur par défaut est selected = "compact", non l’étiquette "Compact".

Q: Comment mettre à jour les choix d’une entrée depuis le server ?

Appelez la fonction update*Input() du widget avec session, l’inputId et les nouveaux choices — par ex. updateSelectInput(session, "dataset", choices = c("mtcars", "iris")). Mettez-la à l’intérieur d’un observe() (exécuté une fois / quand les données changent) ou d’un observeEvent() (exécuté quand une autre entrée change). Vous ne changez que les arguments que vous passez.

Choisissez le bon widget pour chaque type de données, déclarez-le, et lisez sa valeur avec input$.

Programming

Shiny

Tous les widgets d’entrée de Shiny au même endroit : curseurs, texte, listes déroulantes, boutons radio, cases à cocher, dates, téléversements de fichiers et boutons d’action. Pour chacun, le code pour le déclarer, la valeur qu’il renvoie, et quand l’utiliser — plus le contrat inputId → input$ et comment mettre à jour les entrées depuis le server.

Date de publication

28 juin 2026

Modifié

17 juillet 2026

Points clés

Chaque widget suit un seul contrat : son premier argument est un inputId ; vous lisez sa valeur dans le server comme input$<id>.
Adaptez le widget au type de données : un nombre → numericInput/sliderInput ; un choix unique → selectInput/radioButtons ; plusieurs choix → checkboxGroupInput ou selectInput(multiple = TRUE) ; un événement → actionButton.
choices définit les options ; selected/value définit la valeur par défaut. Des choix nommés affichent une étiquette mais renvoient la valeur : c("Compact" = "compact") affiche Compact, renvoie "compact".
Modifiez une entrée depuis le code avec update*Input(session, "id", ...) — même famille que le widget (updateSelectInput, updateSliderInput, …).
Un bouton d’action renvoie un compteur, pas une valeur. Lisez-le avec observeEvent(input$go, { … }), jamais comme un réglage.

Introduction

Les contrôles d’entrée sont la façon dont un utilisateur dialogue avec votre application. Le curseur qu’il déplace, la liste déroulante dans laquelle il choisit, le fichier qu’il téléverse — chacun est un widget que vous placez dans le ui, et chacun produit une valeur que votre server peut lire. Choisir le bon widget pour la tâche et le câbler correctement, c’est l’essentiel de ce qu’est la construction d’une UI.

C’est la référence à laquelle vous revenez. Tous les widgets d’entrée que livre Shiny sont ici, groupés par le type de données qu’ils collectent, et pour chacun vous obtenez trois choses : le code pour le déclarer, la valeur qu’il renvoie, et quand y recourir. Vous connaissez déjà le câblage grâce à votre première application — déclarez un widget, lisez-le côté server. Ici vous apprenez la boîte à outils complète, pour pouvoir choisir et câbler la bonne entrée selon chaque besoin.

Copiez n’importe quel bloc et exécutez-le en local

Le code de cette page n’est pas exécuté ici — une application Shiny a besoin d’une session R active, elle ne peut donc pas tourner dans une page web statique. Copiez n’importe quel bloc dans un fichier app.R et exécutez-le en local avec shiny::runApp() (ou cliquez sur Run App dans RStudio). Chaque exemple montre un widget isolé ; déposez-le dans un ui fluidPage() et lisez sa valeur dans le server.

Pas de R installé ? Essayez une démo d’entrées en direct dans votre navigateur — chaque widget, relié à sa valeur, rien à configurer. Ouvrir dans le Playground ▸

Le contrat inputId

Avant le catalogue, la règle unique qui relie tous les widgets. Le premier argument de chaque entrée est son inputId — une chaîne unique — et cette chaîne est la façon dont vous lisez la valeur de l’entrée dans le server, comme input$<id>.

# ui — declare the widget with an id
sliderInput("bins", "Number of bins:", min = 1, max = 50, value = 30)

# server — read its value by the same id
output$count <- renderText({
  paste("You chose", input$bins, "bins.")
})

L’id "bins" dans le ui et input$bins dans le server sont la connexion. L’id doit être unique dans toute l’application et être un nom R valide (lettres, chiffres, _, . — pas d’espaces, pas de tirets). Tout ce qui suit ne change que quel widget vous déclarez ; le lire reste toujours input$<id>.

Trois autres arguments reviennent sur presque chaque widget :

label — le texte affiché au-dessus ou à côté du contrôle. Passez NULL pour aucune étiquette.
value (entrées texte/numériques/de date) ou selected (entrées à choix) — la valeur par défaut au chargement de l’application.
width — une largeur CSS comme "100%" ou "200px".

Entrées numériques

Pour collecter un nombre — un effectif, un seuil, un âge.

sliderInput() donne une poignée déplaçable bornée par min et max. Il renvoie le nombre sur lequel l’utilisateur s’est arrêté. Utilisez-le quand la plage est connue et que faire glisser est naturel (une année, un pourcentage, un nombre de barres).

sliderInput("year", "Year:", min = 2000, max = 2025, value = 2020)
# input$year  ->  a single number, e.g. 2020

Passez un vecteur de longueur 2 à value et le curseur devient une plage à deux poignées, renvoyant les deux bornes. Utilisez-le pour filtrer entre une borne basse et une borne haute.

sliderInput("price", "Price range:", min = 0, max = 500, value = c(50, 200))
# input$price  ->  c(50, 200), a numeric vector of length 2

numericInput() est une boîte de saisie avec des flèches haut/bas. Il renvoie le nombre saisi (ou NA si la boîte est vidée). Utilisez-le quand la valeur est précise ou non bornée et qu’un curseur serait malcommode.

numericInput("age", "Age:", value = 25, min = 0, max = 120)
# input$age  ->  the number typed, e.g. 25

Entrées texte

Pour du texte libre — un nom, un terme de recherche, un commentaire.

textInput() est une boîte sur une seule ligne. Il renvoie la chaîne saisie, "" avant que l’utilisateur ne tape quoi que ce soit. Utilisez placeholder pour un indice qui disparaît au focus.

textInput("name", "Name:", placeholder = "Enter your name")
# input$name  ->  the string typed, e.g. "Ada", or "" when empty

textAreaInput() est la version multiligne — réglez rows pour sa hauteur. Utilisez-le pour des réponses plus longues comme des commentaires ou des notes.

textAreaInput("notes", "Notes:", rows = 4)
# input$notes  ->  the (possibly multi-line) string

Pour un champ masqué, passwordInput() se comporte exactement comme textInput() mais masque les caractères.

Entrées de sélection (un seul choix)

Pour choisir une seule option dans une liste fixe. La liste va dans choices ; la valeur par défaut va dans selected. Nommez les choix pour séparer l’étiquette de la valeur : c("Compact car" = "compact") affiche Compact car mais input$<id> renvoie "compact".

selectInput() est une liste déroulante — compacte même avec de nombreuses options. Utilisez-la quand la liste est longue ou que vous voulez économiser de l’espace vertical.

selectInput("car", "Car type:",
            choices = c("Compact" = "compact", "Sedan" = "sedan", "SUV" = "suv"),
            selected = "sedan")
# input$car  ->  the selected value, e.g. "sedan"

radioButtons() affiche toutes les options à la fois, l’une d’elles toujours sélectionnée. Utilisez-le pour un petit ensemble (≤ 5) où voir tous les choix aide l’utilisateur à décider. Ajoutez inline = TRUE pour une rangée horizontale compacte.

radioButtons("plot", "Plot type:",
             choices = c("Bar" = "bar", "Line" = "line", "Scatter" = "scatter"),
             selected = "bar")
# input$plot  ->  the selected value, e.g. "bar"

Entrées de sélection (plusieurs choix)

Pour choisir plusieurs options à la fois.

selectInput(multiple = TRUE) transforme la liste déroulante en sélection multiple. Il renvoie un vecteur des valeurs sélectionnées (ou NULL quand rien n’est choisi). Utilisez-le quand les utilisateurs peuvent choisir un nombre quelconque d’éléments dans une longue liste — choices = names(mtcars) est un motif courant pour les sélecteurs de colonnes.

selectInput("vars", "Variables:", choices = names(mtcars), multiple = TRUE)
# input$vars  ->  a character vector, e.g. c("mpg", "wt"), or NULL when empty

checkboxGroupInput() affiche les options sous forme d’une pile de cases à cocher, chacune cochable indépendamment. Même forme de retour — un vecteur des valeurs cochées. Utilisez-le pour un ensemble court et toujours visible de bascules.

checkboxGroupInput("features", "Show:",
                   choices = c("Mean line" = "mean", "Grid" = "grid", "Legend" = "legend"))
# input$features  ->  a character vector of ticked values, e.g. c("mean", "legend")

Pour une seule bascule oui/non, checkboxInput() renvoie un booléen — TRUE quand cochée, FALSE sinon. Utilisez-le pour un unique réglage oui/non.

checkboxInput("smooth", "Add trend line", value = FALSE)
# input$smooth  ->  TRUE or FALSE

Entrées de date

Pour des dates et des plages de dates, avec un sélecteur de calendrier.

dateInput() renvoie un seul objet Date. La valeur par défaut est Sys.Date() (aujourd’hui) à moins que vous ne définissiez value ; format contrôle l’affichage.

dateInput("day", "Pick a day:", value = Sys.Date())
# input$day  ->  a Date, e.g. as.Date("2026-06-28")

dateRangeInput() propose deux calendriers et renvoie un vecteur de longueur 2 de Date — le début et la fin. Utilisez-le pour filtrer des enregistrements entre deux dates.

dateRangeInput("period", "Period:",
               start = Sys.Date() - 30, end = Sys.Date())
# input$period  ->  c(start_date, end_date), two Dates

Téléversement de fichier

fileInput() permet à l’utilisateur de téléverser un fichier. Il ne renvoie pas le contenu du fichier — il renvoie un petit data frame décrivant le téléversement, avec les colonnes dont vous avez besoin pour le lire : datapath (un chemin temporaire sur le server), name (le nom de fichier d’origine), size et type. Restreignez les types acceptés avec accept ; autorisez plusieurs fichiers avec multiple = TRUE.

fileInput("file", "Choose a CSV:", accept = ".csv")
# input$file$datapath  ->  temp path to the uploaded file (read it with read.csv())
# input$file$name      ->  original filename

Dans le server, protégez-vous de l’état vide avec req(input$file) avant de lire, puisque input$file est NULL tant que rien n’est téléversé.

output$preview <- renderTable({
  req(input$file)                       # wait until a file exists
  head(read.csv(input$file$datapath))
})

Bouton d’action

actionButton() est différent de tous les widgets ci-dessus : il ne contient pas un réglage, il signale un événement. Sa valeur est un compteur qui s’incrémente à chaque clic (0 avant le premier clic). Vous ne lisez presque jamais le nombre — vous répondez au clic avec observeEvent() (exécuter des effets de bord) ou eventReactive() (recalculer une valeur seulement au clic).

actionButton("go", "Run analysis")
# input$go  ->  a click counter (0, 1, 2, …) — use it as an event, not a value

# server — do something each time it's clicked
observeEvent(input$go, {
  showNotification("Running…")
})

C’est ainsi que vous faites attendre une application un « Go » explicite au lieu de recalculer à chaque frappe — utile quand un calcul est lent ou que vous voulez que l’utilisateur règle plusieurs entrées d’abord.

actionLink() est la même entrée d’événement de clic rendue sous forme d’un lien hypertexte en ligne plutôt qu’un bouton (par ex. actionLink("go", "Run analysis")) — il renvoie le même compteur entier et vous le lisez de la même façon, avec observeEvent() ou eventReactive().

Quelle entrée pour quelle tâche

Une recherche rapide. Le widget que vous choisissez découle du type de données que vous collectez et du nombre de valeurs que l’utilisateur peut choisir.

Vous avez besoin de…	Utilisez	Renvoie (`input$<id>`)
Un nombre sur une plage connue	`sliderInput()`	un nombre unique
Une plage bas–haut	`sliderInput(value = c(a, b))`	un vecteur numérique de longueur 2
Un nombre précis / non borné	`numericInput()`	un nombre (ou `NA`)
Texte libre court	`textInput()`	une chaîne (`""` si vide)
Texte libre long	`textAreaInput()`	une chaîne
Un secret masqué	`passwordInput()`	une chaîne
Un élément d’une longue liste	`selectInput()`	la valeur sélectionnée
Un élément parmi quelques options visibles	`radioButtons()`	la valeur sélectionnée
Plusieurs éléments d’une longue liste	`selectInput(multiple = TRUE)`	un vecteur (ou `NULL`)
Plusieurs éléments d’une courte liste	`checkboxGroupInput()`	un vecteur (ou `character(0)`)
Une seule bascule oui/non	`checkboxInput()`	`TRUE` / `FALSE`
Une date	`dateInput()`	une `Date`
Une plage de dates	`dateRangeInput()`	deux `Date`
Un téléversement de fichier	`fileInput()`	un data frame (`$datapath`, `$name`, …)
Une action / un événement	`actionButton()`	un compteur de clics (à utiliser avec `observeEvent`)

Mettre à jour une entrée depuis le server

Parfois le server doit modifier un widget après le démarrage de l’application — remplir une liste déroulante à partir de données, réinitialiser un formulaire, ou faire dépendre les choix d’une entrée d’une autre. Chaque widget a une fonction update*Input() correspondante : updateSelectInput(), updateSliderInput(), updateTextInput(), updateRadioButtons(), updateDateInput(), et ainsi de suite. Chacune prend session en premier, puis l’inputId de l’entrée, puis les arguments à modifier.

# server — populate a dropdown's choices from data, after launch
observe({
  updateSelectInput(session, "dataset",
                    choices = c("mtcars", "iris", "airquality"),
                    selected = "mtcars")
})

Les usages courants : charger des choices que vous ne connaissiez pas au démarrage ; réinitialiser un champ avec value = "" / selected = character(0) ; ou chaîner des entrées (quand une liste déroulante de pays change, mettre à jour les choix de la liste déroulante de villes). Vous ne changez que ce que vous passez — omettez choices et les options restent ; passez seulement selected et seule la sélection bouge.

Problèmes fréquents

input$file (ou n’importe quelle entrée) est NULL et votre code génère une erreur. La plupart des entrées démarrent vides : fileInput est NULL tant qu’un fichier n’est pas téléversé, et une sélection multiple renvoie NULL quand rien n’est choisi. Protégez le code du server avec req(input$file) (ou req(input$vars)) pour qu’il attende que l’entrée ait une valeur au lieu de s’exécuter avec NULL et de planter.

Un selectInput/radioButtons n’affiche pas votre valeur par défaut. La valeur selected doit être l’une des valeurs de choices, non l’une des étiquettes. Avec choices = c("Compact" = "compact"), la valeur par défaut est selected = "compact" (la valeur), non selected = "Compact" (l’étiquette). Une non-concordance revient silencieusement à la première option.

Cliquer sur un actionButton ne fait rien. Un bouton ne déclenche que le code qui le surveille. Lire input$go à l’intérieur d’un bloc render* réexécute ce bloc une fois puis plus jamais, car le compteur change rarement la sortie. Mettez le travail à l’intérieur d’observeEvent(input$go, { … }) (pour des effets de bord) ou d’eventReactive(input$go, { … }) (pour une valeur), qui se déclenchent tous deux à chaque clic.

Questions fréquentes

Comment récupérer la valeur d’une entrée Shiny ?

Lisez-la dans le server comme input$<id>, où <id> est l’inputId que vous avez donné au widget. Un curseur déclaré sliderInput("bins", …) se lit comme input$bins ; un selectInput("car", …) comme input$car. L’id doit correspondre exactement, casse comprise.

Comment définir la valeur sélectionnée par défaut d’une entrée ?

Utilisez selected pour les entrées à choix (selectInput, radioButtons, checkboxGroupInput) et value pour les entrées texte, numériques, à curseur et de date. Pour les entrées à choix, selected doit être l’une des valeurs de choices — avec choices = c("Compact" = "compact") la valeur par défaut est selected = "compact", non l’étiquette "Compact".

Comment mettre à jour les choix d’une entrée depuis le server ?

Appelez la fonction update*Input() du widget avec session, l’inputId et les nouveaux choices — par ex. updateSelectInput(session, "dataset", choices = c("mtcars", "iris")). Mettez-la à l’intérieur d’un observe() (exécuté une fois / quand les données changent) ou d’un observeEvent() (exécuté quand une autre entrée change). Vous ne changez que les arguments que vous passez.

Quelle est la différence entre selectInput et radioButtons ?

Les deux collectent un seul choix et renvoient la valeur sélectionnée. radioButtons affiche toutes les options à la fois, il convient donc le mieux à un petit ensemble (≤ 5) où voir tous les choix aide. selectInput masque les options dans une liste déroulante, il est donc préférable pour les longues listes ou pour économiser de l’espace — et il gagne la sélection multiple avec multiple = TRUE.

Que renvoie un actionButton ?

Un compteur de clics — un entier qui démarre à 0 et augmente de 1 à chaque clic. Vous n’utilisez pas le nombre comme un réglage ; vous réagissez au clic avec observeEvent(input$go, { … }) (pour des effets de bord) ou eventReactive(input$go, { … }) (pour recalculer une valeur seulement au clic).

Testez vos connaissances

À vous de jouer : choisir et câbler trois entrées

Vous construisez un panneau de personnalisation de graphique. Ajoutez trois entrées à un sidebarPanel et lisez chacune dans le server : une liste déroulante pour choisir une colonne du jeu de données à tracer, un curseur pour le nombre de barres de l’histogramme (1–50, valeur par défaut 30), et une case à cocher unique pour activer ou désactiver une courbe de tendance. Nommez les ids "col", "bins" et "smooth".

Indice

Un sélecteur de colonne est un choix unique dans une liste → selectInput("col", …, choices = names(mtcars)). Un nombre borné → sliderInput("bins", …, min = 1, max = 50, value = 30). Une bascule oui/non → checkboxInput("smooth", …, value = FALSE). Lisez-les dans le server comme input$col, input$bins et input$smooth.

Solution

sidebarPanel(
  selectInput("col", "Column:", choices = names(mtcars)),
  sliderInput("bins", "Number of bins:", min = 1, max = 50, value = 30),
  checkboxInput("smooth", "Add trend line", value = FALSE)
)

# server reads:
#   input$col     -> a column name, e.g. "mpg"
#   input$bins    -> a number, e.g. 30
#   input$smooth  -> TRUE or FALSE

L’id de chaque widget est la façon dont le server le lit. selectInput et sliderInput renvoient une valeur unique ; checkboxInput renvoie un booléen que vous pouvez utiliser directement dans un if pour ajouter la courbe de tendance.

Vérification rapide

Un selectInput est déclaré avec choices = c("Small" = "sm", "Large" = "lg"). L’utilisateur choisit Large. Que renvoie input$<id> ?

A. "Large" — l’étiquette que l’utilisateur a cliquée. B. "lg" — la valeur associée à cette étiquette. C. c("Small" = "sm", "Large" = "lg") — la liste complète des choix. D. 2 — la position de la sélection.

Afficher la réponse

B. Des choix nommés séparent ce que l’utilisateur voit de ce que le server obtient : l’étiquette Large est affichée, mais input$<id> renvoie sa valeur "lg". C’est pourquoi selected doit aussi être une valeur ("lg"), non une étiquette. A est l’étiquette, non le retour ; C et D ne sont pas la façon dont les entrées à choix rapportent une sélection.

Conclusion

Vous disposez désormais de la boîte à outils d’entrée complète : numériques (sliderInput, numericInput), texte (textInput, textAreaInput), choix unique (selectInput, radioButtons), choix multiple (checkboxGroupInput, selectInput(multiple = TRUE)), une bascule unique (checkboxInput), dates (dateInput, dateRangeInput), téléversements de fichiers (fileInput) et événements (actionButton). Chacune suit le même contrat — déclarez-la avec un inputId, lisez-la comme input$<id> — et chacune renvoie une forme prévisible sur laquelle bâtir la logique du server. Quand l’application doit modifier un widget après le lancement, l’update*Input() correspondant le fait.

Une fois les entrées qui collectent les choix en place, la pièce suivante est l’affichage des résultats : les sorties et les fonctions render* qui les remplissent.

Leçons connexes

Construisez à partir d’ici : programmation réactive — le modèle qui fait recalculer les sorties quand ces entrées changent (le prérequis). Ensuite affichages de sortie montre l’autre moitié — graphiques, tableaux et texte qui réagissent aux entrées que vous venez de déclarer.
Allez plus loin : UI Shiny — la série complète. · Science computationnelle et IA — le pilier.

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

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Contrôles d’entrée Shiny : la référence complète des widgets
    en R},
  date = {2026-06-28},
  url = {https://www.datanovia.com/learn/programming/shiny/ui/input-controls},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Contrôles d’entrée Shiny : la référence complète des widgets en R.” 2026. June 28. https://www.datanovia.com/learn/programming/shiny/ui/input-controls.