改了下格式, 应该好点了 2013/12/13

最近在看Hadley Wickham的Advanced R programming, 初看前面数据结构以及寻值还没觉得什么, 到关于函数和OOP的时候发现好多知识并不太了解,甚至有的没听说过, 毕竟是E文的随手记了些东西, 权当抛个转引个玉. 先把关于函数这一章贴出来,如果有人觉得还有那么一点点用的话, 会考虑把nutshell这本书的笔记和Advanced R programming整理在一起继续发出来

还有很重要的一点, 本人E文不咋地加上看网上看电子版随手记下, 肯定有的地方写的不妥, 欢迎扔砖头

扯淡扯够了, 进入正文吧:

Functions

我们所说的函数一般是closures, 源自于LISP, 仅仅是为了与R的原函数（primitive function)区分

一、函数共有的属性

closures函数都具有三种属性

body(), 返回函数体,显然跟在console中直接输入函数名一样
formals(), 形参, 如何调用参数, pairlist, 每一个参数对应了一个value，因而可以使用alist改变函数的参数
environment(), 函数中变量的作用环境，如果没有指明函数的环境，默认为Globalenv也就是workspace

这三个属性都可以改变函数

<br />
f <- function(x, y = 1, z = 2) {<br />
    x + y + z<br />
}<br />
formals(f) <- alist(x = , y = 100, z = 200)<br />
f<br />
## function (x, y = 100, z = 200)<br />
## {<br />
##     x + y + z<br />
## }<br />
body(f)<br />
## {<br />
##     x + y + z<br />
## }<br />

二、原函数

原函数除了上述三个属性，还包括了.Primitive(), 纯粹用c编写, 全都在base包中, 如sum()和.Primitive(“sum”)()一个意思, 貌似不管我们的事

<br />
## 显示所有原函数<br />
ls("package:base", all = TRUE)<br />

三、作用域

作用域决定了R中符号(symbol)如何去寻值, 两种类型作用域, language level：lexical scoping(词典还是词汇什么什么的作用域实在不知道怎么翻译), 结合在一起来构建函数; 在交互分析中节省type的动态作用域dynamic scoping, computing on the language ?语言计算

词法作用域的寻值方式是由函数的构建方式决定, 通过查看函数的定义就可知道如何寻值, 感觉就是一句话函数的值调用

Advanced R programming对于lexical的说明:

The “lexical” in lexical scoping doesn't correspond to the usual English definition (“of or relating to words or the vocabulary of a language as distinguished from its grammar and construction”) but comes from the computer science term “lexing”, which is part of the process that converts code represented as text to meaningful pieces that the programming language understands. R's lexical scoping is lexical in this sense because you only need the definition of the functions, not how they are called.

四、函数变量寻值

四个基本原则

首先在本函数内部，然后到上一层env，可以是f或者env，直至globalenv，最后是load的其他的package

对于函数

<br />
## 返回一个function<br />
j <- function(x) {<br />
    y <- 2<br />
    function() {<br />
        c(x, y)<br />
    }<br />
}<br />
k <- j(1)<br />
k<br />
## function() {<br />
##         c(x, y)<br />
##     }<br />
## <environment: 0x0344b5c8><br />
k()<br />
## [1] 1 2<br />
rm(j, k)<br />

这是因为函数k记录着自己的作用环境，因为y的值可以捕捉到

五、每一个操作符都是一个函数

To understand computations in R, two slogans are helpful:

Everything that exists is an object.

Everything that happens is a function call.

— John Chambers

曾经用apply的时候经常定义函数function(x)x[2] 其实更简单的是用"[“

<br />
x <- list(1:3, 4:9, 10:12)<br />
sapply(x, "[", 2)<br />
## [1]  2  5 11<br />
sapply(x, function(x) x[2])<br />
## [1]  2  5 11<br />

六、参数

首先匹配名词完全相同, 然后是模糊匹配可以写一个参数的前缀模糊匹配强烈反对代码可读性如果两个参数前缀一样也会出错, 最后按参数的位置

<br />
f <- function(abcdef, bcde1, bcde2) {<br />
    list(a = abcdef, b1 = bcde1, b2 = bcde2)<br />
}<br />
str(f(1, 3, b = 1))<br />
## Error: argument 3 matches multiple formal arguments<br />

如果参数是list df, do.call, 这个楼主经常用, 其实Reduce()也可以实现, 个人感觉Reduce()还是很强大的, 有兴趣的去"?Reduce"

<br />
do.call(mean, list(1:5))<br />
## [1] 3<br />
do.call(cbind, list(c(1, 2), c(2, 3)))<br />
##      [,1] [,2]<br />
## [1,]    1    2<br />
## [2,]    2    3</p>
<p>cbin <- function(x)Reduce("cbind", x)<br />
cbin(list(c(1, 2), c(2, 3)))<br />
##      init<br />
## [1,]    1 2<br />
## [2,]    2 3<br />

参数缺省值, 在定义函数的时候赋值给参数, 甚至可以在函数内部定义缺省值(蛋疼)

<br />
h <- function(a = 1, b = d) {<br />
    d <- (a + 1)^2<br />
    c(a, b)<br />
}<br />
h()<br />
## [1] 1 4<br />
# > [1] 1 4<br />
h(10)<br />
## [1]  10 121<br />
# > [1] 10 121<br />

如果定义了参数，在调用的时候不用, 在函数定义的时候要定义 missing(arg)函数如何计算,missing()只用于函数的构建不建议使用missing, 不如设立缺省值NULL, 在函数内部用 is.null(arg)

七、R计算的懒惰性

<br />
f <- function(x) {<br />
    10<br />
}<br />
system.time(f(Sys.sleep(10)))<br />
##    user  system elapsed<br />
##       0       0       0<br />
因为x并没有没用到，所以函数兵没有执行，可以通过force()来强制执行</p>
<p>f <- function(x) {<br />
    force(x)<br />
    10<br />
}<br />
system.time(f(Sys.sleep(10)))<br />
##    user  system elapsed<br />
##       0       0      10<br />
更有趣的一个例子</p>
<p>add <- function(x) {<br />
    function(y) x + y<br />
}<br />
adders <- lapply(1:10, add)<br />
adders[[1]](10)<br />
## [1] 20<br />
adders[[10]](10)<br />
## [1] 20<br />

在调用add函数的时候, x并没有被evaluate, 所以直至lapp完成x =10, 在add加一句fix(x)会得到正常结果11:20

还需要注意的是默认参数是在函数内部环境中寻值的

<br />
f <- function(x = ls()) {<br />
    a <- 1<br />
    x<br />
}</p>
<p># ls() evaluated inside f:<br />
f()<br />
## [1] "a" "x"</p>
<p># ls() evaluated in global environment:<br />
f(ls())<br />
## [1] "add"    "adders" "f"      "h"      "x"<br />

不知道谁会这样定义参数

一个没有被evaluate的参数在R中称为promise pryr::promise_info可以查看promise的信息

lazy这个特性在if语句中非常有用

<br />
x <- NULL<br />
if (!is.null(x) && x > 0) {</p>
<p>}<br />

NULL > 0是长度为0的逻辑向量, 并不能用于if中，甚至有时候可以避免使用if语句

<br />
if (is.null(a)) stop("a is null")<br />
## Error: object 'a' not found<br />
!is.null(a) || stop("a is null")<br />
## Error: object 'a' not found<br />

八、…

...代表了所有的其他的参数，可以传递给所调用的函数，也可以是自己定义的参数, 最大的用处就是参数传递，省得把所有参数都写上, 但是错误的参数不会报错(都被…吸收了), 如果哪位童鞋编写过自己的Package"..."应该经常用

九、特殊运算符

大多数函数参数都是在函数名之后, 什么 + -等显然不是，我们也可以自定义这种特殊运算符，以%开头结尾, 定义函数的时候函数名-引号

替代函数, 通常含有两个参数，用于修改它的一个参数，返回值则是这个已改变的参数对象

<br />
"second<-" <- function(x, value) {<br />
    x[2] <- value<br />
    x<br />
}<br />
x <- 1:10<br />
second(x) <- 5L<br />
x<br />
##  [1]  1  5  3  4  5  6  7  8  9 10<br />

显然names()什么的属于这一类

十、返回值

函数最主要的就是只调用, 只有返回值影响其工作环境,copy-on-modify semantics

env和引用类除外

library引入新的对象, 函数data等
setwd, Sys.setenv, Sys.setlocale 改变环境变量工作目录语言环境
plot 图形输出
write, write.csv, saveRDS etc 保存数据
options par 改变全局设置
S4 的相关函数改变全局的类和方法
随机数发生器

可以使用invisibleprint的时候不显示返回值, 加上()可以强制显示

[code] a <- 2 (a <- 2) ## [1] 2 # > [1] 2 [/code]

on.exit()也可以跳出函数不如tryCatch

一定要注意的是要加add = TRUE不然会替代前一个调用但是默认参数为FALSE,不推荐使用