L'argument par défaut dans la fonction R (argument formel compensée par de multiples arguments)

Question Simple, je l'espère. Je veux écrire un complot de la fonction qui a une valeur par défaut pour l'axe y de l'étiquette si l'utilisateur ne spécifie pas. Je tiens également à permettre à l' ... argument pour d'autres paramètres de traçage, et de permettre à l'utilisateur de définir ylab manuellement. Mais je ne peux pas comprendre comment le faire.

# simple scatterplot function with a default ylab
scatter <- function(x,y, ...) {
    plot(x, y, ylab="Default y-axis label", ...)
}

# generate data
x <- rnorm(100)
y <- x+rnorm(100)

# use the default
scatter(x,y)

# here I want to use my own label, but I get an error!
scatter(x, y, ylab="New y-axis label")

L'erreur que j'obtiens est: 

Error in plot.default(x, y, ylab = "Default y-axis label", ...) : 
  formal argument "ylab" matched by multiple actual arguments

Je comprends le problème, mais je ne sais pas le meilleur moyen pour résoudre ce problème. Merci pour l'aide!

EDIT: je me rends compte que je peux faire quelque chose comme 

scatter <- function(x,y,ylab = "Default y-axis label", ...) {
    plot(x, y, ylab= ylab, ...)
}

...mais si je suis en train d'écrire un paquet de soumettre à CRAN, et j'ai beaucoup de options par défaut j'aimerais jouer avec, je ne veux pas avoir de documenter ces standard traçage des arguments parce qu'ils sont utilisés dans ma définition de la fonction.

InformationsquelleAutor Stephen Turner | 2014-05-28
  1. 10

    Essayer de faire ceci à la place:

    scatter <- function(x,y,ylab = "Default y-axis label", ...) {
    plot(x, y, ylab= ylab, ...)
}

    Élargissant légèrement sur Arun réponse, c'est une esquisse d'un itinéraire à prendre si vous avez de nombreux arguments:

    def_args <- list(ylab = "Default Label",xlab = "Default Label")

scatter <- function(x,y, ...) {
    cl <- as.list(match.call())[-1L]
    do.call("plot",c(cl,def_args[!names(def_args) %in% names(cl)]))
}

    Certains pensait être nécessaires pour décider de la façon dont vous souhaitez gérer la reconnaissance partielle des arguments (si). par exemple, peut-être quelque chose comme ceci:

    scatter <- function(x,y, ...) {
    cl <- as.list(match.call())[-1L]
    names(cl) <- match.arg(names(cl),
                           names(formals(plot.default)),several.ok = TRUE)
    do.call("plot",c(cl,def_args[!names(def_args) %in% names(cl)]))
}

    serait en mesure de gérer la reconnaissance partielle d'arguments.

    • Cela fonctionne, mais si je suis en train d'écrire un package, c'est encore un autre argument que j'ai du document inutilement. J'ai beaucoup de ces par défaut des paramètres de traçage je veux jouer avec, mais ne veulent pas de document à nouveau.
    • Il me faudrait quelques minutes pour un exemple, mais une option serait de ne pas fournir une par défaut explicite, mais plutôt pour emballer le tout dans ... et puis inspectez ... à l'intérieur de scatter et puis en fonction de ce que l'utilisateur est passé, construire un appel approprié pour plot.
    • c'est à dire exactement ce qui Arun venez de donner.
    • Merci - allons jeter un oeil à ces deux solutions. Vous avez raison, l'astuce sera de traitement de plusieurs permutations de spécifié et "par défaut" des options.
    • Merci. À l'aide de do.call avec la liste des arguments fournis ici résolu le problème à la perfection. Semble comme il y en avait un de moins ick façon de faire cela, mais cela fonctionne bien.
    InformationsquelleAutor joran
  2. 5

    Un chemin à l'aide match.call pour vérifier si ylab a été spécifié comme argument:

    scatter <- function(x,y, ...) {
    mcall = as.list(match.call())[-1L]
    if (!"ylab" %in% names(mcall))
        plot(x, y, ylab="Default y-axis label", ...)
    else plot(x, y, ...)
}

    Comme mentionné dans le commentaire list(...) est plus agréable, pour obtenir les points argument étendu que d'avoir à obtenir tous les arguments formels avec match.call.

    Vous pouvez également essayer d'utiliser pmatch au lieu de %in% pour la reconnaissance partielle d'arguments.

    • N'est-ce pas ... plus facilement perçus comme args <- list(...) à l'intérieur de la fxn?
    • Exactement. L'astuce dans le cas des OP situation est probablement va être mise à l'échelle de ce travail avec un grand nombre d'arguments. Je pensais à quelque chose le long des lignes de disposer d'un ensemble d'arguments par défaut dans une liste prête à y aller, et puis de prendre une "union" avec ... puis de le jeter à do.call ou quelque chose.
    InformationsquelleAutor Arun
  3. 3

    J'utilise une fonction pour construire une liste d'arguments. Dans mon cas, je ne se soucient pas partiellement correspondance des noms d'argument, ce qui est bon parce que ce ne le supportent pas.

    # Create a list of input arguments.
# Allow arguments to be specified multiple times, first definition wins.
# The resulting list is intended to be passed to do.call().

make.args <- function(..., PRE.ARGS=list(), POST.ARGS=list()) {
  a <- list()
  l <- c(PRE.ARGS, list(...), POST.ARGS)
  for (name in unique(names(l))) {
    a[[name]] <- l[[name]] # First occurrence will be found.
  }
  return(a)
}

    Un exemple de son utilisation:

    plot.rate <- function(col, cond=NULL, ...) {
    col <- paste(col, collapse=' + ')
    f <- paste(col, '~ Rate')
    if (!is.null(cond)) {
        cond <- paste(cond, collapse=' + ')
        f <- paste(f, cond, sep='|')
    }

    arg.list <- make.args(...
                    , x = as.formula(f)
                    , main=col
                    , grid=TRUE
                    , scales=list(x=list(alternating=1)    # bottom(/left)
                                , y=list(alternating=3)) # both
                                , xlab='x RTM'
    )

    do.call(xyplot, arg.list)
}
    InformationsquelleAutor Matthew Lundberg