R Academy · Lektion

Vad är en miljö i R?

Utforska miljöer som namngivna listor med pekare till överordnade miljöer.

Lektion 1 av 413 steg

Vad är en miljö i R? är en gratis lektion i R Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.

Vad är en environment?

I R är en environment en samling namngivna bindningar (ungefär som en namngiven lista) samt en pekare till en överordnad environment. Varje variabel finns i någon environment. När R slår upp ett namn söker det först i den aktuella environmenten och går sedan uppåt i kedjan av överordnade environments.

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

R har flera inbyggda environments: globalenv() är er interaktiva arbetsyta, baseenv() innehåller R:s basfunktioner och emptyenv() är toppen av kedjan utan någon överordnad environment. Varje kedja av environments avslutas till slut vid 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')

Kedjan av environments

Varje environment har exakt en överordnad environment, med undantag för emptyenv(). När R inte hittar ett namn i den aktuella environmenten går det vidare till den överordnade, sedan till dess överordnade och så vidare. Det är så R slår upp variabelnamn.

# 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 en funktion

Varje funktion har en tillhörande environment – den environment där den skapades. environment(f) returnerar denna environment. Det är funktionens omslutande environment och avgör var den letar efter fria variabler.

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() på en environment

as.list(env) konverterar en environments bindningar till en namngiven lista, vilket är användbart när ni vill inspektera innehållet programmatiskt. Om ni kombinerar det med globalenv() visas alla variabler i den aktuella sessionen.

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() – Lista innehållet i en environment

ls() listar namnen som är bundna i en environment. Som standard visas den globala environmenten. Ange envir = e för att inspektera en specifik environment. Lägg till all.names = TRUE för att även ta med namn som börjar med ..

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() — Skapa miljöer

new.env(parent = e) skapar en ny tom miljö med den angivna överordnade miljön. Använd emptyenv() som överordnad miljö när Ni vill ha en helt isolerad miljö utan ärvda bindningar.

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

Miljöer jämfört med listor

Miljöer liknar namngivna listor men fungerar annorlunda: de ändras alltid på plats (ingen kopiering vid ändring), de har en överordnad miljö och namn slås upp med en hashtabell (vilket är snabbt). Listor kopieras när de ändras, men miljöer gör det inte.

# 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() och get() i en miljö

exists('name', envir = e) kontrollerar om ett namn är bundet i en miljö (eller i dess överordnade miljöer som standard). get('name', envir = e) hämtar värdet. Båda accepterar inherits = FALSE för att endast söka i den angivna miljön.

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 inbyggda miljöer

environmentName(env) returnerar ett läsbart namn för särskilda miljöer. Egenskapade miljöer returnerar '' (en tom sträng). Detta hjälper Er att spåra var variabler definierades vid felsökning.

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

Praktiskt: använda miljöer som cacheminnen

Eftersom miljöer ändras på plats fungerar de bra som föränderliga cacheminnen eller hashtabeller. Lagra beräknade resultat i en miljö för att slippa beräkna om dem — detta är snabbare än att ändra en lista (som kopieras).

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

Snabb kontroll

Vilken är den översta miljön i R:s miljökedja — den som inte har någon överordnad miljö?

Besvara frågan i den interaktiva lektionen

Miljöer: viktigaste punkterna

Viktigaste punkterna om R-miljöer:

En miljö = namngivna bindningar + en pekare till den överordnade miljön
globalenv() = Er arbetsyta; baseenv() = base R; emptyenv() = kedjans slut
Namn slås upp genom den överordnade kedjan tills de hittas eller emptyenv() nås
ls(envir=e) listar bindningar; exists() kontrollerar; get() hämtar
Miljöer är referensobjekt — de kopieras inte vid ändring
new.env(parent=emptyenv()) skapar en isolerad miljö

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

Gratis att börja

Lär dig R med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 43
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Vad är en miljö i R?” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Vad är en miljö i R?”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Vad är en miljö i R?”?

Utforska miljöer som namngivna listor med pekare till överordnade miljöer. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig R Academy?

Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Vad är en miljö i R?”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här R Academy-lektionen?

Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till R Academy