Holen Sie sich alle Funktionen

In R source()lade ich einige Funktionen:

source("functions.R")

Ist es möglich, die Liste aller in dieser Datei definierten Funktionen abzurufen? Als Funktionsnamen. (Vielleicht source()kann es selbst irgendwie zurückgeben?).

PS: Der letzte Ausweg wäre, das source()zweite Mal aufzurufen local({ source(); })und dann ls()Innen- und Filterfunktionen auszuführen, aber das ist zu kompliziert - gibt es eine einfachere und weniger ungeschickte Lösung?

Ich denke, der beste Weg wäre, die Datei in eine temporäre Umgebung zu bringen. Fragen Sie diese Umgebung nach allen Funktionen ab und kopieren Sie diese Werte in die übergeordnete Umgebung.

my_source <- function(..., local=NULL) {
  tmp <- new.env(parent=parent.frame())
  source(..., local = tmp)
  funs <- names(tmp)[unlist(eapply(tmp, is.function))]
  for(x in names(tmp)) {
    assign(x, tmp[[x]], envir = parent.frame())
  }
  list(functions=funs)
}

my_source("script.R")

Es ist etwas klobig, aber Sie können Änderungen an den Objekten vor und nach dem sourceAufruf wie folgt betrachten.

    # optionally delete all variables
    #rm(list=ls())

    before <- ls()
    cat("f1 <- function(){}\nf2 <- function(){}\n", file = 'define_function.R')
    # defines these
    #f1 <- function() {}
    #f2 <- function() {}
    source('define_function.R')
    after <- ls()

    changed <- setdiff(after, before)
    changed_objects <- mget(changed, inherits = T)
    changed_function <- do.call(rbind, lapply(changed_objects, is.function))
    new_functions <- changed[changed_function]

    new_functions
    # [1] "f1" "f2"

Ich denke, dass dieser reguläre Ausdruck fast jeden gültigen Funktionstyp (Binäroperator, Zuweisungsfunktionen) und jedes gültige Zeichen in einem Funktionsnamen erfasst, aber ich habe möglicherweise einen Randfall übersehen.

# lines <- readLines("functions.R")

lines <- c(
  "`%in%` <- function",
  "foo <- function",
  "foo2bar <- function",
  "`%in%`<-function",
  "foo<-function",
  ".foo <-function",
  "foo2bar<-function",
  "`foo2bar<-`<-function",
  "`foo3bar<-`=function",
  "`foo4bar<-` = function",
  "` d d` <- function", 
  "lapply(x, function)"
)
grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines)
#>  [1]  1  2  3  4  5  6  7  8  9 10
funs <- grep("^`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?\\s*(<-|=)\\s*function", lines, value = TRUE)
gsub("^(`?%?[.a-zA-Z][._a-zA-Z0-9 ]+%?(<-`)?`?).*", "\\1", funs)
#>  [1] "`%in%`"      "foo "        "foo2bar "    "`%in%`"      "foo"        
#>  [6] ".foo "       "foo2bar"     "`foo2bar<-`" "`foo3bar<-`" "`foo4bar<-`"

Wenn dies Ihr eigenes Skript ist, damit Sie die Kontrolle über die Formatierung haben, ist eine einfache Konvention ausreichend. Stellen Sie einfach sicher, dass jeder Funktionsname beim ersten Zeichen in seiner Zeile beginnt und dass das Wort functionauch in dieser Zeile erscheint. Jede andere Verwendung des Wortes functionsollte in einer Zeile erscheinen, die mit einem Leerzeichen oder einer Registerkarte beginnt. Dann ist eine einzeilige Lösung:

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))

Die Vorteile dieses Ansatzes sind die folgenden

• es ist sehr einfach . Die Regeln werden einfach angegeben und es wird nur eine einfache Zeile R-Code benötigt, um die Funktionsnamen zu extrahieren. Regex ist auch einfach und für eine vorhandene Datei sehr einfach zu überprüfen - greifen Sie einfach nach dem Wort functionund prüfen Sie, ob jedes angezeigte Vorkommen der Regel entspricht.

• Die Quelle muss nicht ausgeführt werden. Es ist völlig statisch .

• In vielen Fällen müssen Sie die Quelldatei überhaupt nicht ändern, in anderen Fällen werden nur minimale Änderungen vorgenommen. Wenn Sie das Skript in diesem Sinne von Grund auf neu schreiben, ist es noch einfacher zu arrangieren.

Es gibt viele andere Alternativen entlang der Idee von Konventionen. Sie könnten einen komplexeren regulären Ausdruck haben oder # FUNCTIONam Ende der ersten Zeile einer Funktionsdefinition hinzufügen, wenn Sie das Skript von Grund auf neu schreiben und dann diesen Satz herausgreifen und das erste Wort in der Zeile extrahieren, aber der Hauptvorschlag hier scheint besonders attraktiv aufgrund seiner Einfachheit und der anderen aufgeführten Vorteile.

Prüfung

# generate test file
cat("f <- function(x) x\nf(23)\n", file = "myscript.R") 

sub(" .*", "", grep("^\\S.*function", readLines("myscript.R"), value = TRUE))
## [1] "f"

Dadurch wird der im Beitrag verwendete Code aus meinem Kommentar angepasst, um nach einer Folge von Token (Symbol, Zuweisungsoperator, dann Funktion) zu suchen, und es sollten alle definierten Funktionen erfasst werden. Ich bin nicht sicher, ob es als Antwort von MrFlick robust ist, aber es ist eine andere Option:

source2 <- function(file, ...) {
  source(file, ...)
  t_t <- subset(getParseData(parse(file)), terminal == TRUE)
  subset(t_t, token == "SYMBOL" & 
           grepl("ASSIGN", c(tail(token, -1), NA), fixed = TRUE) & 
           c(tail(token, -2), NA, NA) == "FUNCTION")[["text"]]
}