你也可以使用missing()来测试是否提供了参数y:

fooBar <- function(x,y){
    if(missing(y)) {
        x
    } else {
        x + y
    }
}

fooBar(3,1.5)
# [1] 4.5
fooBar(3)
# [1] 3

老实说，我喜欢OP的第一种方法，实际上开始它与一个NULL值，然后检查它与is。Null(主要是因为它非常简单和容易理解)。这可能取决于人们习惯的编码方式，但Hadley似乎支持is。Null也是:

摘自哈德利的书《高级r》第六章，函数，第84页(网上版本请点击此处查看):

可以通过missing()函数确定是否提供了参数。

i <- function(a, b) {
  c(missing(a), missing(b))
}
i()
#> [1] TRUE TRUE
i(a = 1)
#> [1] FALSE  TRUE
i(b = 2)
#> [1]  TRUE FALSE
i(1, 2)
#> [1] FALSE FALSE

有时您希望添加一个重要的默认值，这可能需要几行代码来计算。如果需要，可以使用missing()有条件地计算它，而不是在函数定义中插入该代码。然而，如果不仔细阅读文档，就很难知道哪些参数是必需的，哪些参数是可选的。相反，我通常将默认值设置为NULL，并使用is.null()来检查是否提供了参数。

以下是我的经验法则:

如果其他参数可以计算出默认值，则使用default 表达式如下:

fun <- function(x,levels=levels(x)){
    blah blah blah
}

否则使用missing

fun <- function(x,levels){
    if(missing(levels)){
        [calculate levels here]
    }
    blah blah blah
}

在极少数情况下，您认为用户可能想要指定一个默认值 它持续整个R会话，使用getOption

fun <- function(x,y=getOption('fun.y','initialDefault')){# or getOption('pkg.fun.y',defaultValue)
    blah blah blah
}

如果根据第一个参数的类应用了一些参数， 使用S3泛型:

fun <- function(...)
    UseMethod(...)


fun.character <- function(x,y,z){# y and z only apply when x is character
   blah blah blah 
}

fun.numeric <- function(x,a,b){# a and b only apply when x is numeric
   blah blah blah 
}

fun.default <- function(x,m,n){# otherwise arguments m and n apply
   blah blah blah 
}

使用……仅当您将附加参数传递给 另一个函数

cat0 <- function(...)
    cat(...,sep = '')

最后，如果你选择使用…不要将圆点传递给另一个函数，警告用户你的函数忽略了任何未使用的参数，否则会非常混乱:

fun <- (x,...){
    params <- list(...)
    optionalParamNames <- letters
    unusedParams <- setdiff(names(params),optionalParamNames)
    if(length(unusedParams))
        stop('unused parameters',paste(unusedParams,collapse = ', '))
   blah blah blah 
}

有几个选项，没有一个是正式的正确方式，也没有一个是真正不正确的，尽管它们可以向计算机和其他阅读您的代码的人传递不同的信息。

对于给定的例子，我认为最明确的选择是提供一个标识默认值，在这种情况下，执行如下操作:

fooBar <- function(x, y=0) {
  x + y
}

这是目前为止显示的最短的选项，简短有助于提高可读性(有时甚至加快执行速度)。很明显，返回的是x和y的和，你可以看到y没有给定一个值，它将是0，当与x相加时，只会得到x。显然，如果使用比加法更复杂的东西，那么就需要一个不同的单位值(如果存在的话)。

我非常喜欢这种方法的一点是，当使用args函数时，甚至在查看帮助文件时，它的默认值都很清楚(你不需要向下滚动到细节，它就在用法中)。

这种方法的缺点是，当默认值很复杂(需要多行代码)时，尝试将所有这些都放在默认值中可能会降低可读性，而missing或NULL方法变得更加合理。

当参数传递给另一个函数或使用匹配时，方法之间的其他一些差异将出现。Call或sys。调用函数。

因此，我认为“正确”的方法取决于您计划对特定参数做什么，以及您想向代码读者传达什么信息。

我倾向于使用NULL来明确什么是必需的，什么是可选的。对于使用依赖于其他参数的默认值，有一个警告，就像Jthorpe建议的那样。该值不是在函数调用时设置的，而是在第一次引用实参时设置的!例如:

foo <- function(x,y=length(x)){
    x <- x[1:10]
    print(y)
}
foo(1:20) 
#[1] 10

另一方面，如果你在改变x之前引用y:

foo <- function(x,y=length(x)){
    print(y)
    x <- x[1:10]
}
foo(1:20) 
#[1] 20

这有点危险，因为它很难跟踪初始化的“y”，就好像它没有在函数的早期被调用一样。

只是想指出，内置的sink函数有很好的例子，可以在函数中设置不同的参数:

> sink
function (file = NULL, append = FALSE, type = c("output", "message"),
    split = FALSE)
{
    type <- match.arg(type)
    if (type == "message") {
        if (is.null(file))
            file <- stderr()
        else if (!inherits(file, "connection") || !isOpen(file))
            stop("'file' must be NULL or an already open connection")
        if (split)
            stop("cannot split the message connection")
        .Internal(sink(file, FALSE, TRUE, FALSE))
    }
    else {
        closeOnExit <- FALSE
        if (is.null(file))
            file <- -1L
        else if (is.character(file)) {
            file <- file(file, ifelse(append, "a", "w"))
            closeOnExit <- TRUE
        }
        else if (!inherits(file, "connection"))
            stop("'file' must be NULL, a connection or a character string")
        .Internal(sink(file, closeOnExit, FALSE, split))
    }
}

这个怎么样?

fun <- function(x, ...){
  y=NULL
  parms=list(...)
  for (name in names(parms) ) {
    assign(name, parms[[name]])
  }
  print(is.null(y))
}

然后尝试:

> fun(1,y=4)
[1] FALSE
> fun(1)
[1] TRUE