R Academy · Leçon

Portée globale ou locale

Q: La leçon « Portée globale ou locale » est-elle gratuite ?

Oui — le texte complet de « Portée globale ou locale » 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.

Q: 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 3 sur 4.

Q: Combien de temps prend la leçon « Portée globale ou locale » ?

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.

Q: 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.

Distinguez .GlobalEnv, les environnements de fonctions et les fermetures.

Portée globale ou locale est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Variables locales dans les fonctions

Les variables affectées avec <- ou = dans le corps d’une fonction sont locales à cette fonction. Elles sont créées dans l’environnement propre à la fonction et disparaissent lorsque celle-ci renvoie son résultat. Elles n’affectent jamais la portée appelante.

x <- 'global'
f <- function() {
  x <- 'local'   # creates a new local binding, does not modify global x
  cat('Inside f: x =', x, '\n')
}
f()
cat('Outside f: x =', x, '\n')  # still 'global'

Les paramètres de fonction sont locaux

Les paramètres de fonction sont également des variables locales. Modifier un paramètre dans la fonction n’affecte pas l’argument dans l’environnement appelant. R transmet les arguments par valeur (avec copie lors de la modification).

double_it <- function(n) {
  n <- n * 2      # modifies local copy only
  cat('Inside:', n, '\n')
}
my_n <- 5
double_it(my_n)
cat('Outside:', my_n, '\n')  # still 5

<<- pour une affectation globale

<<- (affectation globale) remonte la chaîne des parents et affecte la première correspondance trouvée. Si aucune correspondance n’existe, il crée la liaison dans l’environnement global. Utilisez-le avec modération : un usage excessif de <<- rend les fonctions difficiles à comprendre.

total <- 0
add_to_total <- function(x) {
  total <<- total + x
}
add_to_total(10)
add_to_total(25)
add_to_total(5)
cat('Total:', total, '\n')

<<- remonte la chaîne

<<- n’affecte pas aveuglément l’environnement global : il remonte la chaîne des parents et affecte le premier environnement dans lequel le nom existe déjà. Si la variable existe dans une fonction englobante, c’est à cet endroit qu’elle est mise à jour.

outer <- function() {
  n <- 0
  increment <- function() n <<- n + 1
  increment()
  increment()
  cat('n in outer:', n, '\n')  # n was in outer's env, updated there
}
outer()
# n does NOT appear in global env
cat('n in global:', exists('n', envir = globalenv()), '\n')

assign() pour cibler explicitement un environnement

assign('name', value, envir = e) affecte directement une valeur à un environnement précis. Cette approche est plus explicite que <<- et s’avère utile lorsque vous disposez d’un objet environnement et souhaitez y définir une valeur avec précision.

my_env <- new.env(parent = emptyenv())
assign('score', 95, envir = my_env)
assign('name', 'Alice', envir = my_env)
cat('score:', get('score', envir = my_env), '\n')
cat('name :', get('name',  envir = my_env), '\n')

local() — Blocs de code isolés

local({...}) évalue une expression dans un nouvel environnement local. Les variables créées à l’intérieur du bloc ne se propagent pas dans l’environnement global. C’est utile pour les calculs temporaires qui ne doivent pas encombrer l’espace de travail.

result <- local({
  temp1 <- 100
  temp2 <- 200
  temp1 + temp2   # the last expression is returned
})
cat('result:', result, '\n')
cat('temp1 in global:', exists('temp1'), '\n')  # FALSE

local() ou une fonction pour isoler du code

local() et une fonction appelée immédiatement assurent tous deux l’isolation de la portée. local() est plus concis pour une isolation ponctuelle ; une fonction nommée est préférable si vous voulez rendre la logique réutilisable ou la soumettre à des tests.

# Option A: local()
result_a <- local({
  x <- 7
  y <- 3
  x * y
})
# Option B: immediately invoked function
result_b <- (function() {
  x <- 7
  y <- 3
  x * y
})()
cat(result_a, result_b, '\n')
cat('x in global:', exists('x'), '\n')

Lire des variables globales depuis une fonction

Les fonctions peuvent lire des variables depuis leur portée englobante (globale ou autre) sans syntaxe particulière. C’est le fonctionnement standard de la portée lexicale. Toutefois, dépendre fortement de l’état global rend les fonctions plus difficiles à tester — privilégiez les arguments explicites lorsque c’est possible.

tax_rate <- 0.20   # global configuration
apply_tax <- function(price) {
  price * (1 + tax_rate)  # reads tax_rate from global
}
cat(apply_tax(100), '\n')
cat(apply_tax(250), '\n')

Masquage des variables

Lorsqu’une variable locale porte le même nom qu’une variable globale, la liaison locale masque la liaison globale. À l’intérieur de la fonction, c’est la version locale qui est utilisée. La variable globale reste inchangée. Cela peut provoquer des erreurs subtiles si ce comportement n’est pas intentionnel.

mean <- 99   # shadows base R's mean() function
cat(mean, '\n')   # prints 99, not the function
# To call the real mean, use base:: prefix
cat(base::mean(c(1, 2, 3, 4, 5)), '\n')
rm(mean)   # remove the shadow

Environnements de function()

Chaque fois qu’une fonction est appelée, R crée un nouvel environnement pour cet appel, avec l’environnement englobant de la fonction comme parent. Les variables locales de différents appels n’interfèrent pas entre elles, même lors d’appels récursifs.

factorial_r <- function(n) {
  # Each recursive call has its own local n
  if (n <= 1) return(1)
  n * factorial_r(n - 1)
}
cat('5! =', factorial_r(5), '\n')
cat('7! =', factorial_r(7), '\n')

rm() pour supprimer des variables

rm('name') ou rm(name) supprime une liaison de l’environnement actuel (ou indiqué). Utilisez-le pour supprimer les variables temporaires. Transmettez envir = e pour supprimer une liaison d’un environnement précis.

x <- 42
y <- 'hello'
cat('Before rm:', ls(), '\n')
rm(x)
cat('After rm(x):', exists('x'), '\n')
rm('y')
cat('After rm(y):', exists('y'), '\n')

Vérification rapide

Que fait <<- contrairement à une affectation régulière avec <- ?

Portée : points essentiels

Points essentiels concernant la portée globale et locale :

<- à l’intérieur d’une fonction crée une variable locale — la variable globale reste inchangée
Les paramètres de fonction sont locaux ; R les transmet par valeur (copie lors de la modification)
<<- remonte la chaîne des parents et modifie la première liaison correspondante
assign('x', val, envir=e) permet une affectation ciblant explicitement un environnement
local({...}) fournit une portée temporaire sans créer de fonction nommée
Évitez de masquer des noms importants (comme mean, c, T)

# Demonstrate local + <<- cleanly
running_sum <- 0
local({
  values <- c(10, 20, 30, 40)
  for (v in values) running_sum <<- running_sum + v
})
cat('Running sum:', running_sum, '\n')
cat('values in global:', exists('values'), '\n')

Questions Fréquemment Posées

La leçon « Portée globale ou locale » est-elle gratuite ?

Oui — le texte complet de « Portée globale ou locale » 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 « Portée globale ou locale » ?

Distinguez .GlobalEnv, les environnements de fonctions et les fermetures. 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 3 sur 4.

Combien de temps prend la leçon « Portée globale ou locale » ?

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