r - 为什么有人应该使用 {} 来初始化 R 中的空对象？

Question

似乎有些programmers正在使用:

a = {}
a$foo = 1
a$bar = 2

超过 a = list(foo = 1, bar = 2)有什么好处?

为什么要 {}使用？此表达式仅返回 NULL , 所以一个 NULL赋值也会做同样的事情，不是吗？

Answer 1

您的第一个查询

Why should {} be used, this expression only returns NULL, so an NULL assignment would do the same, wouldn't it?

是的， a <- NULL产生相同的效果。使用 {}很有可能是个人风格。
NULL NULL可能是最通用和最容易混淆的 R 对象。来自 R language definition of NULL :

It is used whenever there is a need to indicate or specify that an object is absent. It should not be confused with a vector or list of zero length.

The NULL object has no type and no modifiable properties. There is only one NULL object in R, to which all instances refer. To test for NULL use is.null. You cannot set attributes on NULL.

严格来说， NULL只是 NULL .而这是唯一的 is.null返回 TRUE .然而，根据 ?NULL :

Objects with value NULL can be changed by replacement operators and will be coerced to the type of the right-hand side.

因此，虽然它与具有合法模式的长度为 0 的向量不同(并非 R 中的所有模式都允许在向量中；阅读 ?mode 以获取模式的完整列表和 ?vector 以获取向量的合法内容)，这种灵活的强制转换通常使它表现得像一个长度为 0 的向量:

## examples of atomic mode
integer(0)  ## vector(mode = "integer", length = 0)
numeric(0)  ## vector(mode = "numeric", length = 0)
character(0)  ## vector(mode = "character", length = 0)
logical(0)  ## vector(mode = "logical", length = 0)

## "list" mode
list()  ## vector(mode = "list", length = 0)

## "expression" mode
expression()  ## vector(mode = "expression", length = 0)

您可以进行向量连接:

c(NULL, 0L)  ## c(integer(0), 0L)
c(NULL, expression(1+2))  ## c(expression(), expression(1+2))
c(NULL, list(foo = 1))  ## c(list(), list(foo = 1))

您可以增长一个向量(正如您在问题中所做的那样):

a <- NULL; a[1] <- 1; a[2] <- 2
## a <- numeric(0); a[1] <- 1; a[2] <- 2

a <- NULL; a[1] <- TRUE; a[2] <- FALSE
## a <- logical(0); a[1] <- TRUE; a[2] <- FALSE

a <- NULL; a$foo <- 1; a$bar <- 2
## a <- list(); a$foo <- 1; a$bar <- 2

a <- NULL; a[1] <- expression(1+1); a[2] <- expression(2+2)
## a <- expression(); a[1] <- expression(1+1); a[2] <- expression(2+2)

使用 {}生成 NULL类似于 expression() .虽然不完全相同，但当您稍后使用它做某事时的运行时强制确实使它们无法区分。例如，当增加一个列表时，以下任何一种都可以工作:

a <- NULL; a$foo <- 1; a$bar <- 2
a <- numeric(0); a$foo <- 1; a$bar <- 2  ## there is a warning
a <- character(0); a$foo <- 1; a$bar <- 2  ## there is a warning
a <- expression(); a$foo <- 1; a$bar <- 2
a <- list(); a$foo <- 1; a$bar <- 2

对于具有原子模式的长度为 0 的向量，在运行时强制期间会产生警告(因为从“原子”到“递归”的变化太大了):

#Warning message:
#In a$foo <- 1 : Coercing LHS to a list

我们没有收到表达式设置的警告，因为来自 ?expression :

As an object of mode ‘"expression"’ is a list ...

嗯，它不是通常意义上的“列表”；它是一个类似于列表的抽象语法树。

您的第二个查询

What is the benefit over a = list(foo = 1, bar = 2)?

这样做没有任何好处。你应该已经在其他地方读到过，在 R 中增长对象是一种不好的做法。在谷歌上随机搜索: growing objects and loop memory pre-allocation .
如果你知道向量的长度以及它的每个元素的值，直接创建它，比如 a = list(foo = 1, bar = 2) .
如果您知道向量的长度但要计算其元素的值(例如通过循环)，请设置一个向量并进行填充，例如 a <- vector("list", 2); a[[1]] <- 1; a[[2]] <- 2; names(a) <- c("foo", "bar") .

回复 Tjebo

I actually looked up ?mode, but it doesn't list the possible modes. It points towards ?typeof which then points to the possible values listed in the structure TypeTable in src/main/util.c. I have not been able to find this file not even the folder (OSX). Any idea where to find this?

它意味着 R 发行版的来源，它是 CRAN 上的“.tar.gz”文件。另一种方法是查找 https://github.com/wch/r-source .无论哪种方式，这是表:

TypeTable[] = {
    { "NULL",       NILSXP     },  /* real types */
    { "symbol",     SYMSXP     },
    { "pairlist",   LISTSXP    },
    { "closure",    CLOSXP     },
    { "environment",    ENVSXP     },
    { "promise",    PROMSXP    },
    { "language",   LANGSXP    },
    { "special",    SPECIALSXP },
    { "builtin",    BUILTINSXP },
    { "char",       CHARSXP    },
    { "logical",    LGLSXP     },
    { "integer",    INTSXP     },
    { "double",     REALSXP    }, /*-  "real", for R <= 0.61.x */
    { "complex",    CPLXSXP    },
    { "character",  STRSXP     },
    { "...",        DOTSXP     },
    { "any",        ANYSXP     },
    { "expression", EXPRSXP    },
    { "list",       VECSXP     },
    { "externalptr",    EXTPTRSXP  },
    { "bytecode",   BCODESXP   },
    { "weakref",    WEAKREFSXP },
    { "raw",        RAWSXP },
    { "S4",     S4SXP },
    /* aliases : */
    { "numeric",    REALSXP    },
    { "name",       SYMSXP     },

    { (char *)NULL, -1     }
};