R Language
Umfang der Variablen

Bemerkungen

Umgebungen und Funktionen

Innerhalb einer Funktion deklarierte Variablen existieren nur innerhalb dieser Funktion.

x <- 1

foo <- function(x) {
    y <- 3
    z <- x + y
    return(z)
}

y

Fehler: Objekt 'y' nicht gefunden

In eine Funktion übergebene und dann neu zugewiesene Variablen werden überschrieben, jedoch nur innerhalb der Funktion .

foo <- function(x) {
    x <- 2
    y <- 3
    z <- x + y
    return(z)
}

foo(1)
x

5

1

Variablen, die in einer höheren Umgebung als eine Funktion zugewiesen wurden, sind in dieser Funktion vorhanden, ohne dass sie übergeben werden.

foo <- function() {
    y <- 3
    z <- x + y
    return(z)
}
    
foo()

4

Unterfunktionen

Funktionen, die innerhalb einer Funktion aufgerufen werden (dh Unterfunktionen), müssen innerhalb dieser Funktion definiert werden, um auf Variablen zuzugreifen, die in der lokalen Umgebung definiert sind, ohne weitergegeben zu werden.

Das schlägt fehl:

bar <- function() {
    z <- x + y
    return(z)
}
    
foo <- function() {
    y <- 3
    z <- bar()
    return(z)
}

foo()

Fehler in bar (): Objekt 'y' nicht gefunden

Das funktioniert:

foo <- function() {
    
    bar <- function() {
        z <- x + y
        return(z)
    }
    
    y <- 3
    z <- bar()
    return(z)
}
    
foo()

4

Globale Zuordnung

Variablen können mit <<- aus jeder Umgebung global zugewiesen werden. bar() kann jetzt auf y zugreifen.

bar <- function() {
    z <- x + y
    return(z)
}
    
foo <- function() {
    y <<- 3
    z <- bar()
    return(z)
}

foo()

4

Von der globalen Zuweisung wird dringend abgeraten. Die Verwendung einer Wrapper-Funktion oder das explizite Aufrufen von Variablen aus einer anderen lokalen Umgebung wird stark bevorzugt.

Explizite Zuweisung von Umgebungen und Variablen

Umgebungen in R können explizit aufgerufen und benannt werden. Variablen können explizit zugewiesen werden und von oder zu diesen Umgebungen aufrufen.

Eine häufig erstellte Umgebung ist eine, die package:base oder eine Teilumgebung innerhalb von package:base einschließt.

e1 <- new.env(parent = baseenv())
e2 <- new.env(parent = e1)

Variablen können explizit zugewiesen werden und von oder zu diesen Umgebungen aufrufen.

assign("a", 3, envir = e1)
   get("a", envir = e1)
   get("a", envir = e2)

3

3

Da e2 von erbt e1 , a ist 3 sowohl in e1 und e2 . Durch die Zuweisung von a innerhalb von e2 wird der Wert von a in e1 nicht geändert.

assign("a", 2, envir = e2)
   get("a", envir = e2)
   get("a", envir = e1)

3

2

Funktion beenden

Die Funktion on.exit() ist praktisch für das Bereinigen von Variablen, wenn globale Variablen zugewiesen werden müssen.

Einige Parameter, insbesondere die für die Grafik, können nur global eingestellt werden. Diese kleine Funktion ist bei der Erstellung spezialisierter Diagramme üblich.

new_plot <- function(...) {
     
     old_pars <- par(mar = c(5,4,4,2) + .1, mfrow = c(1,1))
     on.exit(par(old_pars))
     plot(...)
 }

Pakete und Maskierung

Funktionen und Objekte in verschiedenen Paketen können denselben Namen haben. Das später geladene Paket 'maskiert' das frühere Paket und eine Warnmeldung wird gedruckt. Beim Aufruf der Funktion über den Namen wird die Funktion des zuletzt geladenen Pakets ausgeführt. Auf die frühere Funktion kann explizit zugegriffen werden.

library(plyr)
library(dplyr)

Paket anhängen: 'dplyr'

Die folgenden Objekte werden von 'package: plyr' maskiert:

ordnen, zählen, desc, failwith, id, mutieren, umbenennen, zusammenfassen, zusammenfassen

Die folgenden Objekte werden von 'package: stats' maskiert:

filter, lag

Die folgenden Objekte werden von 'package: base' maskiert:

schneiden, setdiff, setequal, union

Beim Schreiben von Code empfiehlt es sich immer, Funktionen explizit mit package::function() aufzurufen, um dieses Problem zu vermeiden.