0Pricing
R Academy · Leçon

Créer et inspecter des environnements

Utilisez new.env(), environment(), ls() et get() pour travailler avec les environnements.

Créer et inspecter des environnements est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Créer un nouvel environnement

new.env(parent = e) crée un nouvel environnement vide. L’argument parent définit l’environnement dans lequel la recherche se poursuit lorsqu’un nom n’est pas trouvé dans le nouvel environnement. Utilisez emptyenv() pour un environnement entièrement isolé.

# Isolated environment (no parent chain)
e1 <- new.env(parent = emptyenv())
# Environment with global as parent
e2 <- new.env(parent = globalenv())
cat('e1 parent:', environmentName(parent.env(e1)), '\n')
cat('e2 parent:', environmentName(parent.env(e2)), '\n')

assign() — Ajouter des liaisons

assign('name', value, envir = e) crée ou met à jour une liaison nommée dans l’environnement indiqué. C’est l’équivalent programmatique de e$name <- value, mais cela fonctionne lorsque le nom est stocké dans une variable.

e <- new.env(parent = emptyenv())
assign('x', 10, envir = e)
assign('y', 'hello', envir = e)
assign('z', TRUE, envir = e)
cat('x:', get('x', envir = e), '\n')
cat('y:', get('y', envir = e), '\n')

get() et mget()

get('name', envir = e) récupère une seule liaison. mget(c('a','b'), envir = e) récupère plusieurs liaisons à la fois et renvoie une liste nommée. Les deux fonctions renvoient une erreur si le nom n’existe pas (sauf si inherits autorise la recherche dans la chaîne).

e <- new.env(parent = emptyenv())
e$alpha <- 1
e$beta  <- 2
e$gamma <- 3
# Single
get('alpha', envir = e)
# Multiple
mget(c('alpha', 'beta', 'gamma'), envir = e)

ls() — Lister les liaisons

ls(envir = e) renvoie un vecteur de caractères contenant tous les noms associés à des valeurs dans l’environnement e. Ajoutez all.names = TRUE pour inclure les noms commençant par . (masqués par défaut). Les noms sont renvoyés dans l’ordre alphabétique.

e <- new.env(parent = emptyenv())
e$b_val  <- 2
e$a_val  <- 1
e$.secret <- 'hidden'
cat('Default ls:', ls(envir = e), '\n')
cat('All names :', ls(envir = e, all.names = TRUE), '\n')

exists() avec inherits

exists('name', envir = e, inherits = FALSE) vérifie uniquement l’environnement indiqué, et non ses parents. Avec inherits = TRUE (valeur par défaut), la recherche s’effectue également dans la chaîne des parents. Utilisez inherits = FALSE pour effectuer des vérifications locales strictes.

parent_e <- new.env(parent = emptyenv())
parent_e$shared <- 42
child_e  <- new.env(parent = parent_e)
# inherits=TRUE: finds shared in parent
cat('inherits TRUE:', exists('shared', envir = child_e, inherits = TRUE),  '\n')
# inherits=FALSE: only looks in child
cat('inherits FALSE:', exists('shared', envir = child_e, inherits = FALSE), '\n')

environmentName() et parent.env()

environmentName(e) renvoie le nom d’un environnement intégré ('R_GlobalEnv', 'package:base', etc.). Les environnements créés par l’utilisateur renvoient ''. parent.env(e) renvoie l’objet environnement parent.

e <- new.env(parent = globalenv())
cat('Name of e     :', environmentName(e), '\n')
cat('Parent of e   :', environmentName(parent.env(e)), '\n')
cat('Name of global:', environmentName(globalenv()), '\n')

Syntaxe $ pour les environnements

Les environnements prennent en charge la syntaxe $ et [[, comme les listes, pour lire et écrire des liaisons. C’est souvent plus pratique que get()/assign() pour un accès direct lorsque le nom est connu au moment de l’écriture.

e <- new.env(parent = emptyenv())
e$pi_approx <- 3.14159
e[['e_approx']] <- 2.71828
cat('pi:', e$pi_approx, '\n')
cat('e :', e[['e_approx']], '\n')

rm() dans un environnement précis

rm('name', envir = e) supprime une liaison d’un environnement précis. Cela diffère de la suppression d’une variable globale : lorsque vous travaillez avec des environnements personnalisés, vous devez indiquer explicitement l’environnement.

e <- new.env(parent = emptyenv())
e$keep <- 1
e$remove_me <- 99
cat('Before:', ls(envir = e), '\n')
rm('remove_me', envir = e)
cat('After :', ls(envir = e), '\n')

as.list() pour exporter un environnement

as.list(e) convertit toutes les liaisons d’un environnement en une liste nommée, ce qui facilite l’inspection ou la sérialisation de son contenu. Le résultat est un instantané : les modifications ultérieures de l’environnement ne sont pas répercutées dans la liste.

e <- new.env(parent = emptyenv())
e$x <- 10
e$y <- 20
e$z <- 30
bindings <- as.list(e)
cat('Class:', class(bindings), '\n')
cat('Length:', length(bindings), '\n')
str(bindings)

Les environnements comme tables de hachage

L’option hash = TRUE de new.env() (valeur par défaut lorsqu’un parent est défini) active la recherche fondée sur le hachage, ce qui rend la recherche de noms en O(1). Les grands environnements sont ainsi beaucoup plus rapides que les listes pour stocker des paires clé-valeur.

# Build a small key-value store
store <- new.env(hash = TRUE, parent = emptyenv())
keys   <- paste0('key_', 1:5)
values <- c(10, 20, 30, 40, 50)
for (i in seq_along(keys)) assign(keys[i], values[i], envir = store)
# Retrieve
cat('key_3 =', get('key_3', envir = store), '\n')
cat('All keys:', ls(store), '\n')

Copie ou partage des environnements

Affecter un environnement à une nouvelle variable ne le copie pas : les deux variables font référence au même objet. Utilisez as.list(), puis list2env() pour créer une véritable copie si vous avez besoin d’environnements indépendants.

e1 <- new.env(parent = emptyenv())
e1$val <- 100
e2 <- e1          # reference, not a copy
e2$val <- 999
cat('e1$val:', e1$val, '\n')  # 999, modified via e2!

# True copy:
e3 <- list2env(as.list(e1), parent = emptyenv())
e3$val <- 0
cat('e1$val after e3 change:', e1$val, '\n')  # still 999

Vérification rapide

Quelle fonction vérifie si un nom est lié dans un environnement sans rechercher dans ses environnements parents ?

Création d’environnements : points essentiels

Points essentiels pour créer et inspecter des environnements :

  • new.env(parent=e) crée un nouvel environnement vide ; hash=TRUE pour les grands ensembles
  • assign('x', v, envir=e) et get('x', envir=e) pour un accès programmatique
  • e$x et e[['x']] fonctionnent comme des accesseurs de liste
  • ls(envir=e) répertorie les noms ; exists('x', envir=e, inherits=FALSE) pour une vérification stricte
  • as.list(e) convertit le contenu en liste ; list2env() le reconstitue
  • Les environnements sont des objets de référence : l’affectation les partage, elle ne les copie pas
config <- new.env(hash = TRUE, parent = emptyenv())
assign('host', 'localhost', envir = config)
assign('port', 5432L,       envir = config)
assign('db',   'mydb',      envir = config)
cat('Keys  :', ls(config), '\n')
cat('host  :', config$host, '\n')
cat('port  :', config$port, '\n')

Questions Fréquemment Posées

La leçon « Créer et inspecter des environnements » est-elle gratuite ?

Oui — le texte complet de « Créer et inspecter des environnements » 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 « Créer et inspecter des environnements » ?

Utilisez new.env(), environment(), ls() et get() pour travailler avec les environnements. 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 4 sur 4.

Combien de temps prend la leçon « Créer et inspecter des environnements » ?

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

  1. Qu’est-ce qu’un environnement dans R ?
  2. Règles de portée lexicale
  3. Portée globale ou locale
  4. Créer et inspecter des environnements
← Retour à R Academy