R 语言运算符：算术、比较、逻辑、%in% 与 %%

R 提供的运算符

R 的运算符分为四组：算术运算符（+ - * / ^ %% %/%）、比较运算符（== != < <= > >=）、逻辑运算符（& | && || ! xor），以及成员检测运算符 %in%。有两点让它们和大多数语言不同：几乎所有运算符都是向量化的，会一次性对整个向量逐元素运算；而且 R 有两个与运算符和两个或运算符，它们不能互换。本页会讲解所有这些运算符，以及会悄悄给出错误答案的优先级陷阱。

算术运算符：+、-、*、/、^、%% 和 %/%

前五个的作用和你预想的一样。用百分号包起来的两个，%%（取模，即余数）和 %/%（整数除法，即商），才是大家常去搜索的：

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

注意 / 总是做浮点除法：17 / 5 是 3.4，永远不会是 3。如果你想要整数部分，%/% 正是为此而生的。

%% 的日常用途是判断能否整除。一个数除以 2 没有余数时，它就是偶数：

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

第二行值得停下来看一看：当操作数为负数时，R 的 %% 返回的结果与除数的符号相同（-7 %% 3 是 2，因为 -7 = -3 * 3 + 2）。有些语言的做法正好相反；如果你在移植代码，记得检查一下。

比较运算符是向量化的

==、!=、<、<=、>、>= 会逐元素比较，返回一个逻辑向量，而不是单个答案：

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

这几乎是 R 中所有筛选操作背后的引擎：你把整个向量和一个值比较，得到一个逻辑掩码，再用这个掩码取子集。对小数使用 == 时要小心：浮点数是近似存储的，所以 0.1 + 0.2 == 0.3 是 FALSE。比较小数时，优先使用 all.equal()，或者检查 abs(x - y) < 1e-9。

逻辑运算符：& 与 &&（经典的混淆）

R 有两个与运算符和两个或运算符，选错是每个人的必经之路。

& 和 | 是向量化的。 它们逐元素组合两个逻辑向量：

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

只要是在为数据构造筛选条件，就用它们：df[df$age > 30 & df$city == "Lisbon", ]。

&& 和 || 是标量运算符，并且会短路求值。 它们接收单个值，返回单个 TRUE/FALSE；如果第一个操作数已经决定了答案，就完全跳过第二个操作数：

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

第二行演示了短路求值：因为 x < 0 是 FALSE，R 根本不会求值 stop() 调用。这正是 && 适合放在 if() 条件中的原因：你可以写 if (!is.na(x) && x > 10)，当 x 是 NA 时，x > 10 这部分会被安全地跳过。

经验法则：向量和数据筛选用 &/|，if() 条件用 &&/||。 而且从 R 4.3 开始，这条规则有了强制力：给 && 或 || 传入长度大于 1 的向量会报错（旧版本的 R 会悄悄只使用第一个元素，这让真正的 bug 隐藏了好多年）。

xor(a, b) 补全了这一组：当两者中恰好一个为 TRUE 时返回 TRUE：

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in%：成员检测

x %in% table 会针对 x 的每个元素询问：“它是否出现在 table 中？”它是实际 R 代码中最常用的运算符之一：

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

被检查的一侧可以是整个向量，这让 %in% 成为按一组允许值筛选行的天然工具。

它也胜过你原本会写的替代方案，也就是用 | 连起来的一串 ==：

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

如果有五个允许的值，== 链就会变成一堵重复的墙；%in% 版本只需要把向量加长。它还有第二个更微妙的优势：%in% 永远不会返回 NA：

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 是 NA，因为 R 无法知道一个未知值是否等于 1，这一行为在缺失值中有深入讲解。这个 NA 接着会毒害它所到达的任何 if()。%in% 总是回答 TRUE 或 FALSE，从而完全绕开了这个问题，所以对可能有缺失值的数据设置条件时，它是更安全的选择。

优先级陷阱

在“R 坏掉了”的时刻中，有两个运算符优先级陷阱占了不成比例的份额。第一，^ 的优先级高于一元负号：

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

第二，冒号的优先级高于二元算术运算：

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

拿不准时就加括号。括号不花任何成本，而且每个读者（包括将来的你）都会和解释器以同样的方式解析它们。

$ 与 [ ]：访问运算符

你还会经常看到 $、[ ] 和 [[ ]]，严格来说它们也是运算符，只不过是用来从数据结构中取值，而不是用来计算的：

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

关于向量、列表和数据框的页面会对它们做完整的讲解，在这里只需要认出它们也属于同一个运算符家族就够了。

要点回顾

• %% 给出余数，%/% 给出整数商；x %% 2 == 0 用来判断偶数。
• 比较运算是向量化的：它们返回一个可以用来筛选的逻辑向量。
• &/| 逐元素组合向量；&&/|| 用于 if() 中的单个值，并且会短路求值。从 R 4.3 开始，对更长的向量使用 && 会报错。
• x %in% table 可以替代串联的 ==，而且永远不会返回 NA。
• -2^2 是 -4，1:n - 1 从 0 开始：拿不准时就加括号。

下一篇：在 if、else 和 ifelse() 中运用这些运算符，也就是 R 的条件语句。