R Academy · Lektion

Globaler vs. lokaler Scope

Q: Ist die Lektion „Globaler vs. lokaler Scope“ kostenlos?

Ja — der vollständige Text von „Globaler vs. lokaler 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.

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

Q: Wie lange dauert die Lektion „Globaler vs. lokaler 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.

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

Unterscheiden Sie zwischen .GlobalEnv, Funktions-Environments und Closures.

Lektion 3 von 413 Schritte

Globaler vs. lokaler Scope ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Lokale Variablen in Funktionen

Variablen, denen innerhalb des Funktionskörpers mit <- oder = ein Wert zugewiesen wird, sind für diese Funktion lokal. Sie werden in der eigenen Umgebung der Funktion erstellt und verschwinden, wenn die Funktion zurückkehrt. Sie wirken sich niemals auf den aufrufenden Gültigkeitsbereich aus.

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'

Funktionsparameter sind lokal

Funktionsparameter sind ebenfalls lokale Variablen. Wenn Sie einen Parameter innerhalb der Funktion ändern, wirkt sich das nicht auf das Argument in der aufrufenden Umgebung aus. R übergibt Argumente als Werte (mit Kopieren-beim-Ändern-Semantik).

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

<<- für globale Zuweisungen

<<- (Superzuweisung) sucht die Kette der übergeordneten Umgebungen nach oben ab und weist dem ersten gefundenen Treffer einen Wert zu. Wenn nirgendwo ein Treffer existiert, erstellt der Operator das Binding in der globalen Umgebung. Verwenden Sie ihn sparsam – eine übermäßige Verwendung von <<- erschwert das Nachvollziehen von Funktionen.

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')

<<- sucht die Kette nach oben ab

<<- weist nicht blind der globalen Umgebung einen Wert zu, sondern läuft die Kette der übergeordneten Umgebungen nach oben ab und weist dem ersten Environment einen Wert zu, in dem der Name bereits existiert. Wenn die Variable in einer einschließenden Funktion existiert, wird sie dort aktualisiert.

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() für die explizite Zielumgebung

assign('name', value, envir = e) weist direkt einer bestimmten Umgebung einen Wert zu. Das ist expliziter als <<- und nützlich, wenn Sie ein Umgebungsobjekt haben und darin gezielt einen Wert setzen möchten.

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() — Isolierte Codeblöcke

local({...}) wertet einen Ausdruck in einer neuen lokalen Umgebung aus. Innerhalb des Blocks erstellte Variablen gelangen nicht in die globale Umgebung. Das ist nützlich für vorübergehende Berechnungen, die den Workspace nicht verunreinigen sollen.

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() vs. Funktion zur Isolation

Sowohl local() als auch eine sofort aufgerufene Funktion sorgen für eine Isolierung des Gültigkeitsbereichs. local() ist für eine einmalige Isolierung kürzer; eine benannte Funktion eignet sich besser, wenn Sie die Logik wiederverwenden oder testen möchten.

# 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')

Globale Variablen aus einer Funktion lesen

Funktionen können Variablen aus ihrem einschließenden Gültigkeitsbereich (global oder nicht) ohne besondere Syntax lesen. Das ist die übliche Funktionsweise lexikalischer Gültigkeitsbereiche. Eine starke Abhängigkeit vom globalen Zustand erschwert jedoch das Testen von Funktionen – bevorzugen Sie nach Möglichkeit explizite Argumente.

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')

Variablenüberschattung

Wenn eine lokale Variable denselben Namen wie eine globale Variable hat, überschattet das lokale Binding das globale. Innerhalb der Funktion wird die lokale Version verwendet. Die globale bleibt unverändert. Wenn dies unbeabsichtigt geschieht, kann es subtile Fehler verursachen.

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

Umgebungen von function()

Bei jedem Aufruf einer Funktion erstellt R eine neue Umgebung für diesen Aufruf, deren übergeordnetes Element die einschließende Umgebung der Funktion ist. Lokale Variablen verschiedener Aufrufe beeinflussen sich nicht, auch nicht bei rekursiven Aufrufen.

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() zum Entfernen von Variablen

rm('name') oder rm(name) entfernt ein Binding aus der aktuellen (oder angegebenen) Umgebung. Verwenden Sie dies, um temporäre Variablen zu bereinigen. Mit envir = e entfernen Sie es aus einer bestimmten Umgebung.

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')

Kurze Überprüfung

Was macht <<-, das eine gewöhnliche Zuweisung mit <- nicht macht?

Beantworte es in der interaktiven Lektion

Gültigkeitsbereich: Wichtigste Erkenntnisse

Wichtigste Erkenntnisse zu globalen und lokalen Gültigkeitsbereichen:

<- innerhalb einer Funktion erstellt eine lokale Variable – die globale bleibt unverändert
Funktionsparameter sind lokal; R übergibt Werte (Kopieren-beim-Ändern)
<<- läuft die Kette der übergeordneten Umgebungen nach oben ab und ändert das erste passende Binding
assign('x', val, envir=e) dient der expliziten Zuweisung an eine Umgebung
local({...}) stellt einen Wegwerf-Gültigkeitsbereich bereit, ohne eine benannte Funktion zu erstellen
Vermeiden Sie die Überschattung wichtiger Namen (wie 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')

Kostenlos starten

Lerne R mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 43
Lektionen: 159

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Globaler vs. lokaler Scope“ kostenlos?

Ja — der vollständige Text von „Globaler vs. lokaler 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 „Globaler vs. lokaler Scope“?

Unterscheiden Sie zwischen .GlobalEnv, Funktions-Environments und Closures. 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 3 von 4.

Wie lange dauert die Lektion „Globaler vs. lokaler 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

← Zurück zu R Academy