在函数内访问函数中的变量

Question

在 R 中运行一个函数时，我会在其中运行另一个函数。 我在这行有一个代码：

f_a <- function(b, c){
    return(b + c)
}

f_e <- function(){
    b = 2
    c = 2 
    d = f_a(b, c)
    print(d)
}

这很好用。我想做的是不将变量传递 b, c 给函数f_a。我想做这样的事情（会引发错误）

f_a <- function(){
    return(b + c)
}

f_e <- function(){
    b = 2
    c = 2
    d = f_a()
    print(d)
}

有没有办法使用环境或搜索路径或任何其他方式来做到这一点？

Answer 1

我鼓励你阅读lexical scoping， 但我认为避免编写大量变量的好方法可能是：

get_args_for <- function(fun, env = parent.frame(), inherits = FALSE, ..., dots) {
    potential <- names(formals(fun))

    if ("..." %in% potential) {
        if (missing(dots)) {
            # return everything from parent frame
            return(as.list(env))
        }
        else if (!is.list(dots)) {
            stop("If provided, 'dots' should be a list.")
        }

        potential <- setdiff(potential, "...")
    }

    # get all formal arguments that can be found in parent frame
    args <- mget(potential, env, ..., ifnotfound = list(NULL), inherits = inherits)
    # remove not found
    args <- args[sapply(args, Negate(is.null))]
    # return found args and dots
    c(args, dots)
}

f_a <- function(b, c = 0, ..., d = 1) {
    b <- b + 1
    c(b = b, c = c, d = d, ...)
}

f_e <- function() {
    b <- 2
    c <- 2
    arg_list <- get_args_for(f_a, dots = list(5))
    do.call(f_a, arg_list)
}

> f_e()
b c d   
3 2 1 5 

默认设置inherits = FALSE确保我们只从指定的环境中获取变量。 我们还可以在调用get_args_for 时设置dots = NULL，这样我们就不会传递所有变量， 但将省略号留空。

尽管如此，它并不完全健壮， 因为dots 只是简单地附加在末尾， 如果某些参数没有命名， 他们最终可能会按位置匹配。 另外，如果调用中的某些值应该是NULL， 不容易被发现。

---

我强烈建议不要在 R 包中使用以下这些。 不仅会比较丑， 你会从 R 的 CMD 检查中得到一堆关于未定义全局变量的注释。

其他选项。

f_a <- function() {
    return(b + c)
}

f_e <- function() {
    b <- 2
    c <- 2
    # replace f_a's enclosing environment with the current evaluation's environment
    environment(f_a) <- environment()
    d <- f_a()
    d
}

> f_e()
[1] 4

上面的东西可能在 R 包中不起作用， 因为我认为包的功能已锁定其封闭环境。

或者：

f_a <- function() {
    with(parent.frame(), {
        b + c
    })
}

f_e <- function() {
    b <- 2
    c <- 2
    f_a()
}

> f_e()
[1] 4

这样您就不会永久修改其他函数的封闭环境。 但是，这两个函数将共享一个环境， 所以可能会发生这样的事情：

f_a <- function() {
    with(parent.frame(), {
        b <- b + 1
        b + c
    })
}

f_e <- function() {
    b <- 2
    c <- 2
    d <- f_a()
    c(b,d)
}

> f_e()
[1] 3 5

调用内部函数会修改外部环境中的值。

还有一个更灵活的选择， 因为它只是通过使用eval 临时修改封闭环境。 但是，有些 R 函数会通过“暗魔法”检测它们当前的执行环境， 并且不能被eval所迷惑； 见this discussion。

f_a <- function() {
    b <- b + 1
    b + c
}

f_e <- function() {
    b <- 2
    c <- 2
    # use current environment as enclosing environment for f_a's evaluation
    d <- eval(body(f_a), list(), enclos=environment())
    c(b=b, d=d)
}

> f_e()
b d 
2 5 

Answer 2

一种选择是从调用环境中显式获取a 和b：

f_a <- function(){
    get('b', envir = parent.frame()) + get('c', envir = parent.frame())
}

f_e <- function(){
    b = 2
    c = 2
    d = f_a()
    d
}

f_e()
#> [1] 4

或者，您可以使用quote 延迟评估，然后eval 在调用环境中评估代码，有效地做同样的事情：

f_a <- function(){
    eval(quote(b + c), parent.frame())
}

不过，这并不是一种真正可靠的代码编写方式，因为它限制了成功调用f_a 的可能方式。遵循显式传递变量的代码要容易得多。

Answer 3

编辑：

@alistaire 建议使用quote 来构造表达式，这带来了这种看起来更丑陋的替代方案：

expr_env <- new.env()
   expr_env$f_a <- quote(b+c)
   expr_env$f_z <- quote(x+y)

f_e<-function(){
    b=2
    c=2
    d=eval( expr_env$f_a)
    print(d)
}

---

使用local 定义函数是否可以接受？

 f_e<-function(){
     b=2
     c=2
     d<-local({
          b+c
              })

     print(d)
 }
 f_e()
[1] 4

另一种方法是只返回一个解析树，然后在函数的“本地”环境中完成评估。这对我来说似乎“丑陋”：

expr_list<-function(){  f_a <- quote(b+c)
                        f_z <- quote(x+y)
list(f_a=f_a,f_z=f_z) }

f_e<-function(){
    b=2
    c=2
    d=eval( (expr_list()$f_a))
    print(d)
}

Answer 4

您可以将变量分配给全局环境并在函数内部使用。

f_a <- function(){
    return(b + c)
}

f_e <- function(){
    assign("b", 2, envir = .GlobalEnv)
    assign("c", 2, envir = .GlobalEnv)
    d = f_a()
    print(d)
}

# > f_e()
# [1] 4