В R, как сделать переменные внутри функции доступными для функции нижнего уровня внутри этой функции? (With, attach, environment)

Ответ 1

(1) Передать зону вызова. Вы можете явно передать родительскую среду и индекс в нее. Попробуй это:

f2a <- function(P, env = parent.frame()) {
    env$calls <- env$calls + 1
    print(env$calls)
    return(P + env$c + env$d)
}

a <- 1
b <- 2
# same as f1 except f2 removed and call to f2 replaced with call to f2a
f1a <- function(){
    c <- 3
    d <- 4
    calls <- 0
    v <- vector()
    for(i in 1:10){
        v[i] <- f2a(P=0)
        c <- c+1
        d <- d+1
      }
     return(v)
}
f1a()

(2) Сброс вызываемой функциональной среды - это сброс среды f2b в f1b как показано здесь:

f2b <- function(P) {
    calls <<- calls + 1
    print(calls)
    return(P + c + d)
}

a <- 1
b <- 2
# same as f1 except f2 removed, call to f2 replaced with call to f2b
#  and line marked ## at the beginning is new
f1b <- function(){
    environment(f2b) <- environment() ##
    c <- 3
    d <- 4
    calls <- 0
    v <- vector()
    for(i in 1:10){
        v[i] <- f2b(P=0)
        c <- c+1
        d <- d+1
      }
     return(v)
}
f1b()

(3) Макрос использованием eval.parent(substitute (...)) Еще один подход заключается в определении макроподобной конструкции, которая эффективно вводит тело f2c inline в f1c1. Здесь f2c совпадает с f2b за исключением calls <- calls + 1 line (no <<- needed) и обертывания всего тела в eval.parent(substitute({...})). f1c совпадает с f1a за исключением того, что вызов f2a заменяется вызовом f2c.

f2c <- function(P) eval.parent(substitute({
    calls <- calls + 1
    print(calls)
    return(P + c + d)
}))

a <- 1
b <- 2
f1c <- function(){
    c <- 3
    d <- 4
    calls <- 0
    v <- vector()
    for(i in 1:10){
        v[i] <- f2c(P=0)
        c <- c+1
        d <- d+1
      }
     return(v)
}
f1c()

(4) defmacro. Это почти то же самое, что и последнее решение, за исключением того, что в пакете gtools используется defmacro чтобы определить макрос, а не делать это самостоятельно. (Также см. Пакет Rcmdr для другой версии defmacro.) Из-за того, как работает defmacro мы также должны передавать calls но поскольку это макрос, а не функция, это просто говорит, что он заменяет calls и не совпадает с передачей calls на функция.

library(gtools)

f2d <- defmacro(P, calls, expr = {
    calls <- calls + 1
    print(calls)
    return(P + c + d)
})

a <- 1
b <- 2
f1d <- function(){
    c <- 3
    d <- 4
    calls <- 0
    v <- vector()
    for(i in 1:10){
        v[i] <- f2d(P=0, calls)
        c <- c+1
        d <- d+1
      }
     return(v)
}
f1d()

Ответ 2

В общем, я бы сказал, что любая переменная, которая нужна внутри функции, должна передаваться через ее аргументы. Кроме того, если его значение необходимо позже, вы передаете его обратно из функции. Не делать этого может довольно быстро привести к странным результатам, например, что, если есть несколько функций, определяющих переменную x, которую нужно использовать. Если количество переменных больше, вы создаете для него настраиваемую структуру данных, например, помещая их в именованный список.

Ответ 3

Можно также использовать функцию, которая переопределяет другие функции в указанной среде.

test_var <- "global"

get_test_var <- function(){
  return(test_var)
}

some_function <- function(){
  test_var <- "local"
  return(get_test_var()) 

}

some_function() # Returns "global". Not what we want here...

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

some_function2 <- function(){
  test_var <- "local"
  # define function locally
  get_test_var2 <- function(){
    return(test_var)
  }
  return(get_test_var2()) 
}

some_function2() # Returns "local", but 'get_test_var2' can't be used in other places.

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

add_function_to_envir <- function(my_function_name, to_envir) {
  script_text <- capture.output(eval(parse(text = my_function_name)))
  script_text[1] <- paste0(my_function_name, " <- ", script_text[1])
  eval(parse(text = script_text), envir = to_envir)
}

some_function3 <- function(){
  test_var <- "local"
  add_function_to_envir("get_test_var", environment()) 
  return(get_test_var()) 
}

some_function3() # Returns "local" and we can use 'get_test_var' from anywhere.

Здесь add_function_to_envir(my_function_name, to_envir) захватывает скрипт функции, анализирует и переоценивает ее в новой среде.

Примечание: имя функции для my_function_name должно быть в кавычках.