R Academy · Lektion

Was ist eine Environment in R?

Erkunden Sie Environments als benannte Listen mit Verweisen auf übergeordnete Environments.

Lektion 1 von 413 Schritte

Was ist eine Environment in R? ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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 eine Umgebung?

In R ist eine Umgebung eine Sammlung benannter Bindings (ähnlich einer benannten Liste) sowie ein Verweis auf eine übergeordnete Umgebung. Jede Variable befindet sich in einer Umgebung. Wenn R einen Namen auflöst, sucht es zuerst in der aktuellen Umgebung und geht dann die Kette der übergeordneten Umgebungen entlang.

# 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() und emptyenv()

R verfügt über mehrere integrierte Umgebungen: globalenv() ist Ihr interaktiver Arbeitsbereich, baseenv() enthält die Basisfunktionen von R und emptyenv() steht am Ende der Kette und hat keine übergeordnete Umgebung. Jede Umgebungskette endet schließlich bei 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')

Die Umgebungskette

Jede Umgebung hat genau eine übergeordnete Umgebung, außer emptyenv(). Wenn R einen Namen in der aktuellen Umgebung nicht findet, geht es zur übergeordneten Umgebung, dann zu deren übergeordneter Umgebung und so weiter. Auf diese Weise löst R Variablennamen auf.

# 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() für eine Funktion

Jede Funktion hat eine zugehörige Umgebung – die Umgebung, in der sie erstellt wurde. environment(f) gibt diese Umgebung zurück. Sie ist die einschließende Umgebung der Funktion und bestimmt, wo nach freien Variablen gesucht wird.

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() auf eine Umgebung anwenden

as.list(env) wandelt die Bindings einer Umgebung in eine benannte Liste um. Das ist nützlich, um ihren Inhalt programmatisch zu untersuchen. In Kombination mit globalenv() werden alle Variablen der aktuellen Sitzung angezeigt.

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() – Inhalt einer Umgebung auflisten

ls() listet die Namen auf, die in einer Umgebung gebunden sind. Standardmäßig wird die globale Umgebung angezeigt. Übergeben Sie envir = e, um eine bestimmte Umgebung zu untersuchen. Fügen Sie all.names = TRUE hinzu, um auch Namen einzuschließen, die mit . beginnen.

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() — Umgebungen erstellen

new.env(parent = e) erstellt eine neue leere Umgebung mit dem angegebenen übergeordneten Element. Verwenden Sie emptyenv() als übergeordnetes Element, wenn Sie eine vollständig isolierte Umgebung ohne geerbte Bindings benötigen.

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

Umgebungen vs. Listen

Umgebungen sehen wie benannte Listen aus, verhalten sich aber anders: Sie werden immer direkt verändert (kein Kopieren beim Ändern), haben ein übergeordnetes Element, und die Namenssuche erfolgt über eine Hash-Tabelle (schnell). Listen werden beim Ändern kopiert, Umgebungen nicht.

# 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() und get() in einer Umgebung

exists('name', envir = e) prüft, ob ein Name in einer Umgebung gebunden ist (standardmäßig auch in deren übergeordneten Umgebungen). get('name', envir = e) ruft den Wert ab. Beide akzeptieren inherits = FALSE, um nur in der angegebenen Umgebung zu suchen.

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() für integrierte Umgebungen

environmentName(env) gibt den für Menschen lesbaren Namen spezieller Umgebungen zurück. Von Benutzern erstellte Umgebungen geben '' (eine leere Zeichenkette) zurück. Das hilft Ihnen beim Debuggen nachzuvollziehen, wo Variablen definiert wurden.

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

Praxis: Umgebungen als Caches verwenden

Da Umgebungen direkt verändert werden, eignen sie sich gut als veränderliche Caches oder Hash-Maps. Speichern Sie berechnete Ergebnisse in einer Umgebung, um erneute Berechnungen zu vermeiden – das ist schneller als das Ändern einer Liste (bei der eine Kopie erstellt wird).

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

Kurze Überprüfung

Welche Umgebung steht in R ganz oben in der Umgebungskette – also diejenige ohne übergeordnetes Element?

Beantworte es in der interaktiven Lektion

Umgebungen: Wichtigste Erkenntnisse

Wichtigste Erkenntnisse zu R-Umgebungen:

Eine Umgebung = benannte Bindings + Zeiger auf das übergeordnete Element
globalenv() = Ihr Workspace; baseenv() = R-Basisumgebung; emptyenv() = Ende der Kette
Die Namenssuche läuft die Kette der übergeordneten Umgebungen nach oben, bis der Name gefunden wird oder emptyenv() erreicht ist
ls(envir=e) listet Bindings auf; exists() prüft sie; get() ruft sie ab
Umgebungen sind Referenzobjekte – beim Ändern wird keine Kopie erstellt
new.env(parent=emptyenv()) erstellt eine isolierte Umgebung

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

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 „Was ist eine Environment in R?“ kostenlos?

Ja — der vollständige Text von „Was ist eine Environment in R?“ 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 „Was ist eine Environment in R?“?

Erkunden Sie Environments als benannte Listen mit Verweisen auf übergeordnete Environments. 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 1 von 4.

Wie lange dauert die Lektion „Was ist eine Environment in R?“?

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