R Academy · Lekcja

Czym jest środowisko w R?

Poznaj środowiska jako nazwane listy ze wskaźnikami do środowisk nadrzędnych.

Czym jest środowisko w R? to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Czym jest środowisko?

W R środowisko to zbiór nazwanych powiązań (podobny do nazwanej listy) oraz wskaźnik do nadrzędnego środowiska. Każda zmienna znajduje się w jakimś środowisku. Podczas wyszukiwania nazwy R najpierw sprawdza bieżące środowisko, a następnie przechodzi w górę łańcucha środowisk nadrzędnych.

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

R ma kilka wbudowanych środowisk: globalenv() to interaktywny obszar roboczy, baseenv() zawiera podstawowe funkcje R, a emptyenv() znajduje się na szczycie łańcucha i nie ma środowiska nadrzędnego. Każdy łańcuch środowisk ostatecznie kończy się na 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')

Łańcuch środowisk

Każde środowisko ma dokładnie jedno środowisko nadrzędne (z wyjątkiem emptyenv()). Gdy R nie znajdzie nazwy w bieżącym środowisku, przechodzi do środowiska nadrzędnego, następnie do jego środowiska nadrzędnego itd. W ten sposób R rozstrzyga nazwy zmiennych.

# 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() dla funkcji

Każda funkcja ma powiązane środowisko — środowisko, w którym została utworzona. environment(f) zwraca to środowisko. Jest to środowisko otaczające funkcję i określa, gdzie funkcja szuka zmiennych wolnych.

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() dla środowiska

as.list(env) konwertuje powiązania środowiska na nazwaną listę, co ułatwia programowe sprawdzanie jego zawartości. Połączenie tej funkcji z globalenv() pokazuje wszystkie zmienne bieżącej sesji.

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() — wyświetlanie zawartości środowiska

ls() wyświetla nazwy powiązane w środowisku. Domyślnie pokazuje środowisko globalne. Przekaż envir = e, aby sprawdzić konkretne środowisko. Dodaj all.names = TRUE, aby uwzględnić nazwy rozpoczynające się od ..

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() — Tworzenie środowisk

new.env(parent = e) tworzy nowe, puste środowisko z podanym środowiskiem nadrzędnym. Użyj emptyenv() jako środowiska nadrzędnego, gdy potrzebujesz całkowicie izolowanego środowiska bez odziedziczonych powiązań.

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

Środowiska a listy

Środowiska przypominają nazwane listy, ale działają inaczej: są zawsze modyfikowane w miejscu (bez kopiowania przy modyfikacji), mają środowisko nadrzędne, a wyszukiwanie nazw odbywa się za pomocą tablicy mieszającej (szybko). Listy są kopiowane podczas modyfikacji, a środowiska nie.

# 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() i get() w środowisku

exists('name', envir = e) sprawdza, czy nazwa jest powiązana ze środowiskiem (lub domyślnie także z jego środowiskami nadrzędnymi). get('name', envir = e) pobiera wartość. Obie funkcje przyjmują inherits = FALSE, aby wyszukiwać tylko w określonym środowisku.

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() dla elementów wbudowanych

environmentName(env) zwraca czytelną dla człowieka nazwę specjalnych środowisk. Środowiska utworzone przez użytkownika zwracają '' (pusty ciąg). Ułatwia to śledzenie miejsca zdefiniowania zmiennych podczas debugowania.

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

Praktyka: używanie środowisk jako pamięci podręcznych

Ponieważ środowiska są modyfikowane w miejscu, dobrze sprawdzają się jako modyfikowalne pamięci podręczne lub mapy mieszające. Przechowuj obliczone wyniki w środowisku, aby uniknąć ich ponownego obliczania — jest to szybsze niż modyfikowanie listy (która jest kopiowana).

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

Szybkie sprawdzenie

Jakie jest najwyższe środowisko w łańcuchu środowisk R — takie, które nie ma środowiska nadrzędnego?

Środowiska: najważniejsze informacje

Najważniejsze informacje o środowiskach R:

Środowisko = nazwane powiązania + wskaźnik do środowiska nadrzędnego
globalenv() = obszar roboczy; baseenv() = bazowe środowisko R; emptyenv() = koniec łańcucha
Wyszukiwanie nazw przebiega w górę łańcucha środowisk nadrzędnych aż do znalezienia nazwy lub dotarcia do emptyenv()
ls(envir=e) wyświetla powiązania; exists() sprawdza ich istnienie; get() pobiera wartości
Środowiska są obiektami referencyjnymi — nie są kopiowane przy modyfikacji
new.env(parent=emptyenv()) tworzy izolowane środowisko

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

Często zadawane pytania

Czy lekcja „Czym jest środowisko w R?” jest bezpłatna?

Tak — pełny tekst „Czym jest środowisko w R?” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Czym jest środowisko w R?”?

Poznaj środowiska jako nazwane listy ze wskaźnikami do środowisk nadrzędnych. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Czym jest środowisko w R?”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do R Academy