0Pricing
R Academy · Lektion

Environments erstellen und untersuchen

Verwenden Sie new.env(), environment(), ls() und get(), um mit Environments zu arbeiten.

Environments erstellen und untersuchen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Eine neue Umgebung erstellen

new.env(parent = e) erstellt eine neue leere Umgebung. Das Argument parent legt fest, in welcher Umgebung gesucht wird, wenn ein Name in der neuen Umgebung nicht gefunden wird. Verwenden Sie emptyenv() für eine vollständig isolierte Umgebung.

# 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() — Bindings hinzufügen

assign('name', value, envir = e) erstellt oder aktualisiert ein benanntes Binding in der angegebenen Umgebung. Es ist das programmatische Äquivalent zu e$name <- value, funktioniert aber auch, wenn der Name in einer Variable gespeichert ist.

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() und mget()

get('name', envir = e) ruft ein einzelnes Binding ab. mget(c('a','b'), envir = e) ruft mehrere Bindings gleichzeitig ab und gibt eine benannte Liste zurück. Beide lösen einen Fehler aus, wenn der Name nicht existiert (außer inherits erlaubt die Suche in der Kette).

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() — Bindings auflisten

ls(envir = e) gibt einen Zeichenvektor mit allen Namen zurück, die in der Umgebung e gebunden sind. Fügen Sie all.names = TRUE hinzu, um auch Namen einzubeziehen, die mit . beginnen (standardmäßig verborgen). Die Namen werden alphabetisch zurückgegeben.

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() mit inherits

exists('name', envir = e, inherits = FALSE) prüft nur die angegebene Umgebung, nicht deren übergeordnete Umgebungen. Mit inherits = TRUE (Standard) wird auch die Kette der übergeordneten Umgebungen durchsucht. Verwenden Sie inherits = FALSE für eine strikt lokale Prüfung.

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() und parent.env()

environmentName(e) gibt den Namen einer integrierten Umgebung zurück ('R_GlobalEnv', 'package:base' usw.). Von Benutzern erstellte Umgebungen geben '' zurück. parent.env(e) gibt das Umgebungsobjekt der übergeordneten Umgebung zurück.

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

$-Syntax für Umgebungen

Umgebungen unterstützen wie Listen die Syntax $ und [[ zum Lesen und Schreiben von Bindings. Für den direkten Zugriff ist das oft praktischer als get()/assign(), wenn der Name beim Schreiben bekannt ist.

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() in einer bestimmten Umgebung

rm('name', envir = e) entfernt ein Binding aus einer bestimmten Umgebung. Das unterscheidet sich vom Entfernen einer globalen Variable – bei benutzerdefinierten Umgebungen müssen Sie die Umgebung explizit angeben.

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() zum Ausgeben einer Umgebung

as.list(e) konvertiert alle Bindings einer Umgebung in eine benannte Liste, sodass sich deren Inhalt leicht untersuchen oder serialisieren lässt. Das Ergebnis ist ein Schnappschuss – spätere Änderungen an der Umgebung werden in der Liste nicht widergespiegelt.

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)

Umgebungen als Hash-Tabellen

Die Option hash = TRUE in new.env() (Standard, wenn ein übergeordnetes Element gesetzt ist) aktiviert die hashbasierte Suche, sodass die Namenssuche O(1) benötigt. Dadurch sind große Umgebungen für die Speicherung von Schlüssel-Wert-Paaren deutlich schneller als Listen.

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

Umgebungen kopieren oder gemeinsam verwenden

Wenn Sie eine Umgebung einer neuen Variable zuweisen, wird sie nicht kopiert – beide Variablen verweisen auf dasselbe Objekt. Verwenden Sie as.list() und anschließend list2env(), um bei Bedarf eine echte Kopie mit unabhängigen Umgebungen zu erstellen.

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

Kurzer Test

Welche Funktion prüft, ob ein Name an eine Umgebung gebunden ist, ohne deren übergeordnete Umgebungen zu durchsuchen?

Umgebungen erstellen: Die wichtigsten Punkte

Die wichtigsten Punkte zum Erstellen und Untersuchen von Umgebungen:

  • new.env(parent=e) erstellt eine neue leere Umgebung; hash=TRUE für große Speicher
  • assign('x', v, envir=e) und get('x', envir=e) für den programmgesteuerten Zugriff
  • e$x und e[['x']] funktionieren wie Listenzugriffe
  • ls(envir=e) listet Namen auf; exists('x', envir=e, inherits=FALSE) für eine strikte Prüfung
  • as.list(e) wandelt in eine Liste um; list2env() stellt die Umgebung wieder her
  • Umgebungen sind Referenzobjekte – eine Zuweisung teilt sie, statt sie zu kopieren
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')

Häufig gestellte Fragen

Ist die Lektion „Environments erstellen und untersuchen“ kostenlos?

Ja — der vollständige Text von „Environments erstellen und untersuchen“ 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 „Environments erstellen und untersuchen“?

Verwenden Sie new.env(), environment(), ls() und get(), um mit Environments zu arbeiten. 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 4 von 4.

Wie lange dauert die Lektion „Environments erstellen und untersuchen“?

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

  1. Was ist eine Environment in R?
  2. Regeln für lexikalischen Scope
  3. Globaler vs. lokaler Scope
  4. Environments erstellen und untersuchen
← Zurück zu R Academy