R Academy · Lekcja

Tworzenie i analizowanie środowisk

Q: Czy lekcja „Tworzenie i analizowanie środowisk” jest bezpłatna?

Tak — pełny tekst „Tworzenie i analizowanie środowisk” 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.

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

Q: Ile czasu zajmuje lekcja „Tworzenie i analizowanie środowisk”?

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.

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

Używaj new.env(), environment(), ls() i get() do pracy ze środowiskami.

Lekcja 4 z 413 kroki

Tworzenie i analizowanie środowisk to bezpłatna lekcja R Academy na CoddyKit. To lekcja 4 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.

Tworzenie nowego środowiska

new.env(parent = e) tworzy nowe, puste środowisko. Argument parent określa, które środowisko zostanie przeszukane, gdy nazwa nie zostanie znaleziona w nowym środowisku. Użyj emptyenv(), aby uzyskać całkowicie izolowane środowisko.

# 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() — dodawanie powiązań

assign('name', value, envir = e) tworzy lub aktualizuje nazwane powiązanie w określonym środowisku. Jest programowym odpowiednikiem e$name <- value, ale działa również wtedy, gdy nazwa jest przechowywana w zmiennej.

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

get('name', envir = e) pobiera pojedyncze powiązanie. mget(c('a','b'), envir = e) pobiera jednocześnie wiele powiązań, zwracając nazwaną listę. Obie funkcje zgłaszają błąd, jeśli nazwa nie istnieje (chyba że inherits zezwala na przeszukiwanie łańcucha).

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() — wyświetlanie powiązań

ls(envir = e) zwraca wektor znakowy wszystkich nazw powiązanych ze środowiskiem e. Dodaj all.names = TRUE, aby uwzględnić nazwy zaczynające się od . (domyślnie ukryte). Nazwy są zwracane w kolejności alfabetycznej.

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

exists('name', envir = e, inherits = FALSE) sprawdza tylko określone środowisko, bez jego środowisk nadrzędnych. Przy inherits = TRUE (wartość domyślna) przeszukuje również łańcuch środowisk nadrzędnych. Użyj inherits = FALSE do ścisłego sprawdzania lokalnego.

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

environmentName(e) zwraca nazwę wbudowanego środowiska ('R_GlobalEnv', 'package:base' itd.). Środowiska utworzone przez użytkownika zwracają ''. parent.env(e) zwraca obiekt środowiska nadrzędnego.

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

Składnia $ dla środowisk

Środowiska obsługują składnię $ i [[, podobnie jak listy, do odczytywania i zapisywania powiązań. Często jest to wygodniejsze niż get()/assign() przy bezpośrednim dostępie, gdy nazwa jest znana w chwili zapisu.

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() w określonym środowisku

rm('name', envir = e) usuwa powiązanie z określonego środowiska. Różni się to od usunięcia zmiennej globalnej — podczas pracy z niestandardowymi środowiskami trzeba jawnie wskazać środowisko.

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() do zrzucania zawartości środowiska

as.list(e) konwertuje wszystkie powiązania w środowisku na nazwaną listę, ułatwiając sprawdzanie lub serializowanie zawartości. Wynik jest migawką — późniejsze zmiany w środowisku nie zostaną odzwierciedlone na liście.

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)

Środowiska jako tablice mieszające

Opcja hash = TRUE w new.env() (domyślna, gdy ustawiono środowisko nadrzędne) włącza wyszukiwanie oparte na tablicy mieszającej, dzięki czemu wyszukiwanie nazw ma złożoność O(1). Sprawia to, że duże środowiska są znacznie szybsze od list przy przechowywaniu par klucz–wartość.

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

Kopiowanie a współdzielenie środowisk

Przypisanie środowiska do nowej zmiennej nie tworzy jego kopii — obie zmienne wskazują ten sam obiekt. Jeśli potrzebuje Pan/Pani niezależnych środowisk, proszę użyć as.list(), a następnie list2env(), aby utworzyć rzeczywistą kopię.

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

Szybkie sprawdzenie

Która funkcja sprawdza, czy nazwa jest powiązana ze środowiskiem, bez przeszukiwania jego środowisk nadrzędnych?

Odpowiedz w interaktywnej lekcji

Tworzenie środowisk: najważniejsze informacje

Najważniejsze informacje dotyczące tworzenia i sprawdzania środowisk:

new.env(parent=e) tworzy nowe, puste środowisko; hash=TRUE sprawdza się w przypadku dużych zbiorów
assign('x', v, envir=e) i get('x', envir=e) służą do programistycznego dostępu
e$x i e[['x']] działają jak akcesory listy
ls(envir=e) wyświetla nazwy; exists('x', envir=e, inherits=FALSE) służy do ścisłego sprawdzania
as.list(e) konwertuje środowisko na listę; list2env() odtwarza środowisko
Środowiska są obiektami referencyjnymi — przypisanie je współdzieli, a nie kopiuje

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

Bezpłatny start

Ucz się R dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 43
Lekcje: 159

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Tworzenie i analizowanie środowisk” jest bezpłatna?

Tak — pełny tekst „Tworzenie i analizowanie środowisk” 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 „Tworzenie i analizowanie środowisk”?

Używaj new.env(), environment(), ls() i get() do pracy ze środowiskami. Ć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 4 z 4.

Ile czasu zajmuje lekcja „Tworzenie i analizowanie środowisk”?

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