R Academy · Leçon

Qu’est-ce qu’un environnement dans R ?

Découvrez les environnements comme des listes nommées munies de pointeurs vers leur parent.

Leçon 1 sur 413 étapes

Qu’est-ce qu’un environnement dans R ? est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 qu’un environnement ?

Dans R, un environnement est un ensemble de liaisons nommées, comparable à une liste nommée, auquel s’ajoute un pointeur vers un environnement parent. Chaque variable se trouve dans un environnement. Lorsque R recherche un nom, il commence par l’environnement courant, puis remonte la chaîne des parents.

# The global environment holds your session variables
x <- 42
cat('x is in globalenv:', exists('x', envir = globalenv()), '\n')
cat('globalenv name:', environmentName(globalenv()), '\n')

globalenv(), baseenv() et emptyenv()

R possède plusieurs environnements intégrés : globalenv() est votre espace de travail interactif, baseenv() contient les fonctions de base de R et emptyenv() est le sommet de la chaîne, sans parent. Toute chaîne d’environnements se termine finalement par emptyenv().

cat('global    :', environmentName(globalenv()),  '\n')
cat('base      :', environmentName(baseenv()),    '\n')
cat('empty     :', environmentName(emptyenv()),   '\n')
cat('parent of global:', environmentName(parent.env(globalenv())), '\n')

La chaîne des environnements

Chaque environnement possède exactement un parent, à l’exception de emptyenv(). Lorsque R ne trouve pas un nom dans l’environnement courant, il passe au parent, puis au parent de celui-ci, et ainsi de suite. C’est ainsi que R résout les noms de variables.

# Walk the parent chain from globalenv
env <- globalenv()
for (i in 1:5) {
  cat(sprintf('Level %d: %s\n', i, environmentName(env)))
  if (identical(env, emptyenv())) break
  env <- parent.env(env)
}

environment() pour une fonction

Chaque fonction possède un environnement associé : celui dans lequel elle a été créée. environment(f) renvoie cet environnement. Il s’agit de l’environnement englobant de la fonction, qui détermine où celle-ci recherche les variables libres.

f <- function() 'hello'
cat('f was defined in:', environmentName(environment(f)), '\n')

# Inside a function, environment() returns its own env
show_env <- function() {
  cat('my env:', environmentName(environment()), '\n')
}
show_env()

as.list() sur un environnement

as.list(env) convertit les liaisons d’un environnement en une liste nommée, ce qui est utile pour inspecter son contenu par programmation. En l’associant à globalenv(), vous pouvez afficher toutes les variables actuelles de la session.

a <- 10
b <- 'hello'
c_val <- TRUE
# Show current global bindings as list
bindings <- as.list(globalenv())
cat('Names in globalenv:', paste(ls(globalenv()), collapse = ', '), '\n')

ls() — Lister le contenu d’un environnement

ls() liste les noms liés dans un environnement. Par défaut, il affiche l’environnement global. Transmettez envir = e pour inspecter un environnement précis. Ajoutez all.names = TRUE pour inclure les noms commençant par ..

my_env <- new.env(parent = emptyenv())
my_env$x <- 1
my_env$y <- 'two'
my_env$.hidden <- TRUE
cat('Default ls:', ls(envir = my_env), '\n')
cat('All names :', ls(envir = my_env, all.names = TRUE), '\n')

new.env() — Création d’environnements

new.env(parent = e) crée un nouvel environnement vide avec le parent indiqué. Utilisez emptyenv() comme parent lorsque vous voulez un environnement totalement isolé, sans aucune liaison héritée.

e <- new.env(parent = emptyenv())
e$name  <- 'Alice'
e$score <- 95
cat('Names:', ls(e), '\n')
cat('Name binding:', e$name, '\n')

Environnements et listes

Les environnements ressemblent à des listes nommées, mais leur comportement diffère : ils sont toujours modifiés sur place (sans copie lors de la modification), possèdent un parent et la recherche de noms s’effectue au moyen d’une table de hachage (rapidement). Les listes sont copiées lorsqu’elles sont modifiées, contrairement aux environnements.

# Environments are reference objects (no copy-on-modify)
e <- new.env(parent = emptyenv())
e$x <- 1
f <- e        # f points to same env, not a copy
f$x <- 99
cat('e$x after modifying through f:', e$x, '\n')

exists() et get() dans un environnement

exists('name', envir = e) vérifie si un nom est associé à une valeur dans un environnement (ou dans ses parents par défaut). get('name', envir = e) récupère la valeur. Les deux fonctions acceptent inherits = FALSE pour effectuer la recherche uniquement dans l’environnement indiqué.

e <- new.env(parent = emptyenv())
e$pi_approx <- 3.14159
cat('exists pi_approx:', exists('pi_approx', envir = e), '\n')
cat('exists missing:  ', exists('missing_var', envir = e), '\n')
cat('get pi_approx:   ', get('pi_approx', envir = e), '\n')

environmentName() pour les environnements intégrés

environmentName(env) renvoie le nom lisible des environnements spéciaux. Les environnements créés par l’utilisateur renvoient '' (chaîne vide). Cela vous aide à déterminer où les variables ont été définies lors du débogage.

cat(environmentName(globalenv()),    '\n')  # R_GlobalEnv
cat(environmentName(baseenv()),      '\n')  # package:base
cat(environmentName(emptyenv()),     '\n')  # R_EmptyEnv
e <- new.env(parent = emptyenv())
cat('User env name: "', environmentName(e), '"\n', sep = '')

En pratique : utiliser les environnements comme caches

Comme les environnements sont modifiés sur place, ils conviennent bien aux caches modifiables ou aux tables de hachage. Stockez les résultats calculés dans un environnement pour éviter de les recalculer — c’est plus rapide que de modifier une liste (qui est copiée).

cache <- new.env(parent = emptyenv(), hash = TRUE)
cached_square <- function(n) {
  key <- as.character(n)
  if (exists(key, envir = cache, inherits = FALSE))
    return(get(key, envir = cache))
  result <- n^2
  assign(key, result, envir = cache)
  result
}
cat(cached_square(7), '\n')
cat(cached_square(7), '\n')  # served from cache

Vérification rapide

Quel est l’environnement situé tout en haut de la chaîne d’environnements de R, celui qui n’a pas de parent ?

Réponds-y dans la leçon interactive

Environnements : points essentiels

Points essentiels concernant les environnements de R :

Un environnement = des liaisons nommées + un pointeur vers le parent
globalenv() = votre espace de travail ; baseenv() = R de base ; emptyenv() = fin de la chaîne
La recherche d’un nom remonte la chaîne des parents jusqu’à ce qu’il soit trouvé ou que emptyenv() soit atteint
ls(envir=e) liste les liaisons ; exists() vérifie leur existence ; get() récupère leur valeur
Les environnements sont des objets référencés — ils ne sont pas copiés lors d’une modification
new.env(parent=emptyenv()) crée un environnement isolé

e <- new.env(parent = emptyenv())
assign('counter', 0L, envir = e)
for (i in 1:5) assign('counter', e$counter + 1L, envir = e)
cat('Counter:', e$counter, '\n')
cat('Env name:', environmentName(e), '\n')
cat('Bindings:', ls(e), '\n')

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Qu’est-ce qu’un environnement dans R ? » est-elle gratuite ?

Oui — le texte complet de « Qu’est-ce qu’un environnement dans R ? » 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 « Qu’est-ce qu’un environnement dans R ? » ?

Découvrez les environnements comme des listes nommées munies de pointeurs vers leur parent. 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 1 sur 4.

Combien de temps prend la leçon « Qu’est-ce qu’un environnement dans R ? » ?

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

← Retour à R Academy