Regeln für lexikalischen Scope
Verstehen Sie, wie R Variablen durch die Suche in übergeordneten Environments findet.
Regeln für lexikalischen Scope ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist lexikalischer Gültigkeitsbereich?
Lexikalischer Gültigkeitsbereich bedeutet, dass eine Funktion Variablen dort sucht, wo sie definiert wurde, und nicht dort, wo sie aufgerufen wird. R verwendet lexikalische Gültigkeitsbereiche. Das ist vorhersehbar: Die Umgebung, in der eine Funktion sucht, wird bei ihrer Erstellung festgelegt, nicht beim Aufruf.
x <- 'global'
f <- function() {
cat('x =', x, '\n') # looks where f was defined (global)
}
local({
x <- 'local to local block'
f() # still prints global x, not the local one
})Lexikalischer vs. dynamischer Gültigkeitsbereich
Bei dynamischem Gültigkeitsbereich (der in einigen anderen Sprachen verwendet wird) würde eine Funktion die Variable in der aufrufenden Umgebung finden. R verwendet stattdessen einen lexikalischen Gültigkeitsbereich: Die einschließende Umgebung zum Zeitpunkt der Definition hat immer Vorrang. Dadurch verhalten sich Funktionen unabhängig vom Aufrufort konsistent.
val <- 100
make_adder <- function(n) {
# n is captured from the definition environment
function(x) x + n
}
add10 <- make_adder(10)
add20 <- make_adder(20)
cat(add10(5), '\n') # 15 — n=10 from definition
cat(add20(5), '\n') # 25 — n=20 from definitionFreie Variablen und Closures
Eine Variable innerhalb einer Funktion, die weder ein Parameter noch eine lokale Zuweisung ist, wird als freie Variable bezeichnet. R sucht sie in der einschließenden Umgebung. Eine Funktion, die freie Variablen erfasst, wird als Closure bezeichnet.
base_rate <- 0.05 # free variable captured by f
f <- function(principal, years) {
principal * (1 + base_rate) ^ years
}
cat('5 yr return:', f(1000, 5), '\n')
# Even if we change base_rate later:
base_rate <- 0.08
cat('New rate return:', f(1000, 5), '\n')Closures erfassen Umgebungen
Bei jedem Aufruf einer Factory-Funktion erfasst die zurückgegebene Funktion (Closure) einen Schnappschuss der einschließenden Umgebung. Unterschiedliche Aufrufe erzeugen Closures mit unterschiedlichen erfassten Werten – darauf basieren Funktionsfabriken.
power_fn <- function(exp) {
function(x) x ^ exp
}
square <- power_fn(2)
cube <- power_fn(3)
cat('square(4) =', square(4), '\n')
cat('cube(3) =', cube(3), '\n')Der Operator <<-
<<- (Zuweisung mit Doppelpfeil) sucht in der Kette der übergeordneten Umgebungen nach einem vorhandenen Binding und ändert es direkt. Wenn kein Binding gefunden wird, erstellt der Operator eines in der globalen Umgebung. Er dient dazu, eine Variable aus einer Funktion heraus in einem einschließenden Gültigkeitsbereich zu ändern.
count <- 0
increment <- function() {
count <<- count + 1
}
increment()
increment()
increment()
cat('count:', count, '\n')<<- mit Closures
Die idiomatischste Verwendung von <<- erfolgt innerhalb von Closures, die einen Zustand in ihrer einschließenden Umgebung aktualisieren müssen. So entstehen zustandsbehaftete Funktionen – Funktionen mit persistentem Speicher zwischen Aufrufen.
make_counter <- function() {
n <- 0
list(
increment = function() n <<- n + 1,
get = function() n,
reset = function() n <<- 0
)
}
ctr <- make_counter()
ctr$increment()
ctr$increment()
cat('Count:', ctr$get(), '\n')
ctr$reset()
cat('After reset:', ctr$get(), '\n')Gültigkeitsbereiche in verschachtelten Funktionen
Wenn Funktionen verschachtelt sind, kann die innere Funktion Variablen sehen, die in der äußeren Funktion definiert wurden. Die Umgebung der äußeren Funktion wird zur einschließenden Umgebung der inneren Funktion und bildet eine Kette.
outer <- function() {
greeting <- 'Hello'
inner <- function(name) {
# greeting comes from outer's environment
paste(greeting, name)
}
inner('World')
}
cat(outer(), '\n')Die Kette der Gültigkeitsbereiche durchsuchen
Wenn R eine Variable sucht, durchsucht es die Umgebungen in dieser Reihenfolge: eigene Umgebung der Funktion → einschließende Umgebung → einschließende Umgebung der einschließenden Umgebung → ... → globale Umgebung → Suchpfad → Basisumgebung → leere Umgebung. Der erste Treffer wird verwendet.
x <- 'global'
f <- function() {
x <- 'local to f'
g <- function() {
# g has no x, so looks in f's env
cat('g sees x =', x, '\n')
}
g()
}
f()environment() einer Funktion
Sie können die einschließende Umgebung jeder Funktion mit environment(f) untersuchen. Sie können sie sogar mit environment(f) <- e festlegen. Dadurch ändert sich, wo die Funktion nach freien Variablen sucht – eine leistungsfähige, aber fortgeschrittene Technik.
x <- 'global_x'
f <- function() x
cat('f sees:', f(), '\n')
# Change f's enclosing environment
my_env <- new.env(parent = emptyenv())
my_env$x <- 'env_x'
environment(f) <- my_env
cat('f now sees:', f(), '\n')Praxisbeispiel für Closures: Memoisierung
Lexikalische Gültigkeitsbereiche und <<- ermöglichen Memoisierung: Aufwendige Funktionsergebnisse werden in der Umgebung der Closure zwischengespeichert. Der Cache ist für die Closure privat und bleibt zwischen Aufrufen erhalten.
make_memoized_fib <- function() {
cache <- c()
function(n) {
if (!is.null(cache[n])) return(cache[n])
if (n <= 1) { cache[n] <<- n; return(n) }
result <- Recall(n-1) + Recall(n-2)
cache[n] <<- result
result
}
}
fib <- make_memoized_fib()
cat(sapply(0:8, fib), '\n')Stolperstein beim lexikalischen Gültigkeitsbereich: Schleifenvariablen
Ein klassischer Stolperstein ist das Erstellen von Closures innerhalb einer Schleife. Alle Closures erfassen dieselbe Umgebung, nicht einen Schnappschuss des Werts. Wenn sie aufgerufen werden, enthält die Schleifenvariable bereits ihren endgültigen Wert.
fns <- vector('list', 3)
for (i in 1:3) {
local({
captured_i <- i
fns[[captured_i]] <<- function() captured_i
})
}
cat(fns[[1]](), fns[[2]](), fns[[3]](), '\n')Kurze Überprüfung
Wo sucht eine Funktion beim lexikalischen Gültigkeitsbereich von R nach einer freien Variable (also einer Variable, die nicht in der Funktion selbst definiert ist)?
Lexikalischer Gültigkeitsbereich: Wichtigste Erkenntnisse
Wichtigste Erkenntnisse zum lexikalischen Gültigkeitsbereich:
- R verwendet lexikalische Gültigkeitsbereiche – Funktionen suchen Variablen dort, wo sie definiert wurden
- Eine Funktion erfasst ihre einschließende Umgebung als Closure
- Freie Variablen werden zum Zeitpunkt der Definition aufgelöst, nicht beim Aufruf
<<-ändert ein Binding in der Kette der übergeordneten Umgebungen (oder in der globalen Umgebung, wenn es nicht gefunden wird)- Closures +
<<-= zustandsbehaftete Funktionen mit persistentem privatem Zustand - Stolperstein bei Closures in Schleifen: Verwenden Sie
local(), um pro Iteration eine neue Umgebung zu erzwingen
make_multiplier <- function(factor) {
function(x) x * factor
}
double <- make_multiplier(2)
triple <- make_multiplier(3)
cat('double(7):', double(7), '\n')
cat('triple(7):', triple(7), '\n')
cat('double env factor:', get('factor', envir = environment(double)), '\n')Häufig gestellte Fragen
Ist die Lektion „Regeln für lexikalischen Scope“ kostenlos?
Ja — der vollständige Text von „Regeln für lexikalischen Scope“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Regeln für lexikalischen Scope“?
Verstehen Sie, wie R Variablen durch die Suche in übergeordneten Environments findet. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Regeln für lexikalischen Scope“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Was ist eine Environment in R?
- Regeln für lexikalischen Scope
- Globaler vs. lokaler Scope
- Environments erstellen und untersuchen