A Forward-Pipe Operator for R
1.基本用法
x %>% f 等价于 f(x)
x %>% f(y) 等价于 f(x, y)
x %>% f %>% g %>% h 等价于 h(g(f(x)))
----------------------------------
x %>% f(y, .) 等价于 f(y, x)
x %>% f(y, z = .) 等价于 f(y, z = x)
如果数据作为函数的第一个参数的话，是不需要占位符placeholder的，但是如果是第二或者更后面的参数，就需要使用 . 作为占位符。
2.构建函数
f <- . %>% cos %>% sin
等价为
f <- function(.) sin(cos(.))
3.%>%, %$%和%<>%的用法
%>%是最常用的一种前向管道符。
%<>%是表示将变量传入函数，得到的结果返回给原来的变量
iris %<>% na.omit() 等价于 iris<-na.omit(iris)
%$%是使用变量的name来表示该变量下name的数值
df<-data.frame("a"=c(1,2,3), "b"=c(4,5,6))
cor(df$a, df$b) 等价于 df %$% cor(a,b)
Overview
The magrittr package offers a set of operators which make your code more readable by:
magrittr工具箱提供了一系列运算符可以使代码可读性提升。
structuring sequences of data operations left-to-right (as opposed to from the inside and out),通过从左到右代替从内到外，格式化数据操作序列
avoiding nested function calls, 避免函数嵌套
minimizing the need for local variables and function definitions, and 减少局部变量和函数定义的数量
making it easy to add steps anywhere in the sequence of operations. 在操作中便于添加步骤
The operators pipe their left-hand side values forward into expressions that appear on the right-hand side, i.e. one can replace f(x) with x %>% f(), where %>% is the (main) pipe-operator. When coupling several function calls with the pipe-operator, the benefit will become more apparent. Consider this pseudo example:
the_data <-
read.csv('/path/to/data/file.csv') %>%
subset(variable_a > x) %>%
transform(variable_c = variable_a/variable_b) %>%
head(100)
Four operations are performed to arrive at the desired data set, and they are written in a natural order: the same as the order of execution. Also, no temporary variables are needed. If yet another operation is required, it is straightforward to add to the sequence of operations wherever it may be needed.
If you are new to magrittr, the best place to start is the pipes chapter in R for data science.
Basic piping
x %>% f is equivalent to f(x)
x %>% f(y) is equivalent to f(x, y)
x %>% f %>% g %>% h is equivalent to h(g(f(x)))
Here, “equivalent” is not technically exact: evaluation is non-standard, and the left-hand side is evaluated before passed on to the right-hand side expression. However, in most cases this has no practical implication.
The argument placeholder
x %>% f(y, .) is equivalent to f(y, x)
x %>% f(y, z = .) is equivalent to f(y, z = x)
Re-using the placeholder for attributes
It is straightforward to use the placeholder several times in a right-hand side expression. However, when the placeholder only appears in a nested expressions magrittr will still apply the first-argument rule. The reason is that in most cases this results more clean code.
x %>% f(y = nrow(.), z = ncol(.)) is equivalent to f(x, y = nrow(x), z = ncol(x))
The behavior can be overruled by enclosing the right-hand side in braces:
x %>% {f(y = nrow(.), z = ncol(.))} is equivalent to f(y = nrow(x), z = ncol(x))
Building (unary) functions
Any pipeline starting with the . will return a function which can later be used to apply the pipeline to values. Building functions in magrittr is therefore similar to building other values.
f <- . %>% cos %>% sin
# is equivalent to
f <- function(.) sin(cos(.))
Pipe with exposition of variables
Many functions accept a data argument, e.g. lm and aggregate, which is very useful in a pipeline where data is first processed and then passed into such a function. There are also functions that do not have a data argument, for which it is useful to expose the variables in the data. This is done with the %$% operator:
iris %>%
subset(Sepal.Length > mean(Sepal.Length)) %$%
cor(Sepal.Length, Sepal.Width)
#> [1] 0.3361992
data.frame(z = rnorm(100)) %$%
ts.plot(z)