北京大学R语言教程(李东风)第19章：函数进阶

`%+%` <- function(x, y) paste0(x, y)
"xyz" %+% "123"

x <- 1:2
names(x) <- c("a", "b")
x

x <- 1:2
`*tmp*` <- x
x <- `names<-`(x, c("a", "b"))
rm(`*tmp*`)
x

x <- 1:5
x <- `[<-`(x, 1, 999)
x

x <- -1
f0 <- function(x){
  f1 <- function(){
    x + 100
  }
  f1()
}

f0 <- function(){
  f1 <- function(){
    x <- -1
    f2 <- function(){
      x + 100
    }
    f2()
  }
  x <- 1000
  f1()
}
f0()

f0 <- function(){
  x <- -1
  f1 <- function(){
    x + 100
  }
  x <- 1000
  f1()
}
f0()

solve.sqe <- function(x){
  fd <- function(a, b, c) b^2 - 4*a*c
  d <- fd(x[1], x[2], x[3])
  if(d >= 0){
    return( (-x[2] + c(1,-1)*sqrt(d))/(2*x[1]) )
  } else {
    return( complex(real=-x[2], imag=c(1,-1)*sqrt(-d))/(2*x[1]) )
  }
}

f <- function(x, y=ifelse(x>0, TRUE, FALSE)){
  x <- -111
  if(y) x*2 else x*10
}
f(5)

基本调试策略

自己编写的某些涉及到复杂的算法的程序可能一开始并不能给出期望的结果。
这包括如下的情况：

• 程序报错，
  需要找到出错的地方加以纠正；
• 程序正常运行，
  输出了结果，
  但是结果明显有错；
• 最糟糕的是，
  程序结果也看起来很正常，
  但实际结果是错误的。

以上这三种情况是依次越来越糟糕的。
直接运行出错的情况一般是比较容易处理的。

为了尽可能保证程序结果正确，
在自己编写新算法时，
要运用模块化思想，
将问题分解为若干个小问题，
使得每一个小问题都比较容易验证结果是否正确，
将每一个小问题编写成一个单独的函数，
这样也可以避免一段很长的程序中许多变量混杂在一起。

在划分模块并编写好程序后，
应该编写一系列的测试函数，
对每个函数进行测试，
保证其在各种情况下的结果是正确的。
最好采纳R的规则化的测试策略进行自动化测试，
在编写R扩展包时就推荐同时提供测试代码。

如果程序还是有错误，
首先可以求助于搜索引擎、用户社区等。
如果这个问题是常见问题，
往往这样就可以解决问题。

如果问题没有解决，
需要将问题最小化：
减少引起错误的程序的复杂程度，
将不必要的代码尽可能用固定的输入数据代替，
使得出错程序很短，
而且错误可重复。
有时会有不可重复的错误，
这样的错误往往很难解决，
超出了一般R用户的能力。

在将问题程序简化并且错误可重复以后，
就要试图定位错误。
一般编程语言都有如下的一些一般性查错(debugging)方法：

• 在程序中适当位置加上输出命令（语句），
  输出怀疑有错的变量值。
• 某些变成语言提供了跟踪以及条件跟踪命令，
  可以在程序运行到某个语句或者触发了某个条件时程序中止，
  但允许用户控制逐行运行程序并随时查看变量值，
  称为跟踪调试(tracing)。
  跟踪调试可以是命令行工具，
  也可以是集成在RStudio这样的集成编程环境中的图形界面工具。

在查错时，
科学研究思维照样起作用：
根据错误表现提出可能的原因假设，
制作测试输入数据验证假设，
记录相应输出并分析是否与假设的错误原因吻合。
如此反复直到找到出错原因并加以纠正。

查错并纠正就可能会破坏了成熟的代码，
造成新的错误，
所以最好能有自动化的测试策略，
在每次修改程序后都重新测试程序是否保持输出正确。

找到出错的函数

在较复杂的程序出错时，
需要首先将错误定位到某一函数调用。如：

f1 <- function(x) f2(x)
f2 <- function(x) 1/x
f1("abc")
## Error in 1/x : 二进列运算符中有非数值参数

为了在多层次函数调用中找到出错的函数，可以用如下命令：

traceback()
## 2: f2(x) at #1
## 1: f1("abc")

结果是所谓的反向追踪(traceback)，
一般编程语言中称为调用栈(calling stack)。
这个输出是从下向上堆叠显示，
下层是调用方，
上层是被调用方。

在RStudio中运行时，
出错程序的右端可以显示“Show Traceback”以及“Rerun with Debug”快捷图标，
点击“Show Traceback”图标也可以显示反向追踪结果。
如果是一个源文件用source命名或图标运行时出错，
在显示反向追踪结果时还可以显示调用的各命令所在的程序行号。
点击“Rerun with Debug”可以进入跟踪调试状态，
显示出错时的运行环境中的变量值。

跟踪调试

R和RStudio提供了很好的跟踪运行程序的能力。
R的browser()命令可以用在程序中，
命令进入跟踪调试；
RStudio的源文件显示界面可以用鼠标点击定义跟踪调试位置。

函数定义一般都包含多行，所以一般不在命令行定义函数，
而是把函数定义以及较长的程序写在源程序文件中，
用source命令运行。
用source命令调入运行的程序与在命令行运行的效果基本相同，
这样定义的变量也是全局变量。

考虑如下函数定义:

f <- function(x){
  for(i in 1:n){
    s <- s + x[i]
  }
}

这个函数定义有许多问题。
用一个测试输入调用f，发现有错误:

print(f(1:5))
## Error in 1:n : NA/NaN参数

简单的函数可以直接仔细检查发现错误，
用cat, print等输出中间结果查找错误。
R提供了一个browser()函数，
在程序中插入对browser()函数的调用，
可以进入跟踪调试状态，
可以实时地查看甚至修改运行时变量的值。

在RStudio的编辑窗口中打开.R源程序文件，
在某一程序行行号左端的空白处用鼠标单击，
就可以设定某一行为断点，
在用source命令运行到该处时就可以进入跟踪调试状态。

加入browser()命令后的程序如：

f <- function(x){
  browser()
  for(i in 1:n){
    s <- s + x[i]
  }
}

程序运行遇到browser()函数或设定的断点时程序进入跟踪调试状态，
命令行的提示符变成“Browse[1]>”。
这个命令行的环境一般不再是全局环境，
而是断点所在的函数的运行环境，
可以看到函数的局部变量。
可以在调试环境中用命令去查看当前定义的变量值、逐个命令地运行，
但是用RStudio则可以更方便地执行这些操作。

在调试命令行，可以使用如下命令：

• 输入变量名查看变量值；
• 用n命令或者换行键逐句运行；
• 用s命令跟踪进调用的函数内部逐句运行；
• 用f命令快速执行到循环末尾或者函数末尾；
• 用c命令恢复正常运行，不再跟踪；
• 用Q命令强行终止程序运行。

进入调试状态后，
RStudio界面提供了相应的支持。
这时RStudio的命令行窗格(Console)将会显示用于控制运行的图标，
包括执行下一语句（Next）、跟踪进入要调用的函数运行(Step into)、执行到函数末尾或者循环末尾(Finish)、不再跟踪继续正常运行（Continue）、终止运行（Stop）。
同时，
在RStudio的Environment窗格中会显示当前执行的命令所在的运行环境的内容，
包括函数内的局部变量；
如果点击其中的下拉菜单还可以显示函数的各层父环境。
在同一窗格中还会显示向后追踪(Traceback)，
即函数是如何被调用的。

为调试如上函数f的程序，
在定义中插入对browser()的调用如:

f <- function(x){
  browser()
  for(i in 1:n){
    s <- s + x[i]
  }
}

当在RStudio中调试运行时，
程序编辑窗口将显示当前要运行的程序行，
用命令行窗口(Console)的Next快捷图标可以运行到下一行。
命令行的显示如：

> print(f(1:5))
Called from: eval(expr, p)
Browse[1]> n
debug在D:/disk/projects/Rbookweb/tmp2.R#2: for (i in 1:n) {
    s <- s + x[i]
}
Browse[2]> 

继续用“Next”图标运行，命令行结果如：

Browse[2]> n
Error in 1:n : NA/NaN参数

发现是在for(i in 1:n)行遇到未定义的变量n。

在源文件中把出错行改为for(i in 1:length(x))，
再次运行,
发现在运行s <- s + x[i]行时，
遇到“错误: 找不到对象’s’”。
这是忘记初始化引起的。
在for语句前添加s <- 0语句，函数定义变成：

f <- function(x){
  browser()
  s <- 0
  for(i in 1:length(x)){
    s <- s + x[i]
  }
}

再次运行，
在跟踪到循环时，
为了避免繁琐的跟踪过程，
可以用“执行到函数末尾或者循环末尾”快捷图标或命令行的f命令，
或者“Continue”快捷图标或命令行的c命令。
程序不显示错误但是也没有显示结果为NULL而不是我们期望得输入元素之和。
检查可以看出错误是忘记把函数返回值写在函数定义最后。

在函数定义最后添加s一行，
再次运行，程序结果与手工验算结果一致。
函数变成

f <- function(x){
  browser()
  n <- length(x)
  s <- 0
  for(i in 1:n){
    s <- s + x[i]
  }
  s
}

自定义函数应该用各种不同输入测试其正确性和稳定性。
比如，上面的函数当自变量x为零长度向量时应该返回0才合适，
但是上面的写法会返回一个numeric(0)结果，
这个结果表示长度为零的向量：

f(numeric(0))
## Called from: f(numeric(0))
## Browse[1]> c
## numeric(0)

程序输入了零长度自变量，
我们期望其输出为零而不是numeric(0)。
在自变量x为零长度时，
函数中for(i in 1:length(x)应该一次都不进入循环，
跟踪运行可以发现实际对i=1和i=0共运行了两轮循环。
把这里的1:length(x)改成seq_along(x)解决了问题，
seq_along(x)生成x的下标序列，
如果x是零长度的则下标序列为零长度向量。

函数不需要修改后，
可以把对browser()的调用删除或注释掉，
在RStudio中关闭断点。
函数最终修改为：

f <- function(x){
  s <- 0
  for(i in seq_along(x)){
    s <- s + x[i]
  }
  s
}

这里只是用这个简单函数演示如何调试程序，
求向量元素和这个问题本身是不需要我们去定义新函数的，
sum函数本来就是完成这样的功能。
实际上，许多我们认为需要自己编写程序做的事情，
在R网站都能找到别人已经完成的扩展包。

条件断点

用browser()函数与R的if结构配合可以制作条件断点。
比如，
在调试带有循环的程序时，
发现错误发生在循环内，
如果从循环开始就跟踪运行，
会浪费许多时间。
设已知错误发生在循环变量i等于501的时候，
就可以在循环内插入：

这样就可以在更接近出错的位置进入跟踪运行。

开启对一个函数的调试

可以用debug(f)命令对函数f开启跟踪运行，
这时每次调用f()时都会自动进入跟踪运行状态。
用undebug(f)取消对f的这种操作。

出错调试选项

比较长的程序在调试时如果从开头就跟踪，
比较耗时。可以设置成出错后自动进入跟踪模式，
检查出错时的变量值。只要进行如下设置：

则在出错后可以选择进入出错的某一层函数内部,
在browser环境中跟踪运行。

在RStudio中调试某一源程序文件时，
可以选择“Debug–On Error”菜单，
并选择“Break in Code”，
就可以在出错时自动在出错处进入跟踪状态。

例如，用options()函数进行设置后，
前面那个求向量元素和的例子程序按最初的定义，
运行时出现如下的选择：

## Error in f(1:5) : object 'n' not found
## 
## Enter a frame number, or 0 to exit   
## 
## 1: f(1:5)
## 
## Selection: f(1:5)
## 
## Selection: 1
## Called from: top level 
## Browse[1]> 

在Selection后面输入了1，就进入了函数内部跟踪。
用Q终止运行并退出整个browser跟踪。
当函数调用函数时可以选择进入哪一个函数进行跟踪。
如果在RStudio中设置了“Break in Code”，
会自动在出错处进入跟踪运行状态。

stop()、warning()、message()

编写程序时应尽可能提前发现不合法的输入和错误的状态。
发现错误时，
可以用stop(s)使程序运行出错停止，
其中s是一个字符型对象，
用来作为显示的出错信息。

发现某些问题后如果不严重，
可以不停止程序运行，
但用warning(s)提交一个警告信息，
其中s是字符型的警告信息。
警告信息的显示可能比实际运行要延迟一些。

有些警告信息实际是错误，
用options()的warn参数可以设置警告级别，
如设置warn=2则所有警告当作错误处理。
设置如

其中warn=0是默认做法，
warn=1表示不延迟显示。

函数message()与stop()、warning()类似，
不算是错误或者警告，
是提示性的信息输出。
message()不会像warning()那样延迟显示。
比如，
长时间的等待之前给出一个提示，
正在读写文件或者网络时给出提示，
等等。
与cat()等相比较，
cat()是用户要求的输出，
而message()是程序员对用户的提示。

预防性设计

在编写自定义函数时，
可以检查自变量输入以确保输入符合要求。
函数stopifnot可以指定自变量的若干个条件，
当自变量不符合条件时自动出错停止。

例如，函数f()需要输入两个数值型向量x, y,
需要长度相等，
可以用如下的程序

f <- function(x, y){
  stopifnot(is.numeric(x),
            is.numeric(y),
            length(x)==length(y))
  ## 函数体程序语句...
}

出错处理机制

R运行可以用stop()产生错误状态，
停止运行；
用warning()产生警告，
用message()产生提示。
基本R提供了tryCatch()函数，
用来保护可能出错的代码，
并可以指定出错时用的恢复或诊断代码。
try()函数也可以保护可能出错的代码，
使得出错时错误信息照样显示但不中断运行。

扩展包rlang提供了一些对出错处理机制的增强功能。
详见(Hadley Wickham 2019)第8章：Conditions。

simple.return <- function(x){
  x <- as.vector(x)
  c(NA, diff(x) / x[1:(length(x)-1)])
}

library(testthat)
test_that("simple.return calculates simple return", {
  expect_equal(simple.return(c(1, 2, 3)), 
    c(NA, 1, 0.5))
  expect_equal(simple.return(ts(c(1, 2, 3))), 
    c(NA, 1, 0.5))
  expect_equal(simple.return(ts(c(1, 2, 3), 
    start=c(2000,1), frequency=12)), 
    c(NA, 1, 0.5))
})

基本概念

e1 <- rlang::env(
  a = FALSE,
  b = "a",
  c = 2.3,
  d = 1:3)

e1$e <- list(x=1, y="abcd")

e1
## <environment: 0x000001d185e88860>

rlang::env_print(e1)
## <environment: 000001D185E88860>
## parent: <environment: global>
## bindings:
##  * a: <lgl>
##  * b: <chr>
##  * c: <dbl>
##  * d: <int>
##  * e: <list>

rlang::env_names(e1)
## [1] "a" "b" "c" "d" "e"

e1 <- rlang::env(a=1, b=2)
e2 <- rlang::env(e1, c=3, d=4)

rlang::env_print(e1)
## <environment: 000001D185DDE7D0>
## parent: <environment: global>
## bindings:
##  * a: <dbl>
##  * b: <dbl>
rlang::env_parent(e2)
## <environment: 0x000001d185dde7d0>
rlang::env_parents(e2)
## [[1]]   <env: 000001D185DDE7D0>
## [[2]] $ <env: global>

f0 <- function(){
  x <- 0
  f1 <- function(){
    f2 <- function(){
      x <<- x+1
      x
    }
    f2()
  }
  f1
}
f01 <- f0()
f01()

## [1] 1

## [1] 2

e1 <- rlang::env(rlang::empty_env(), x=1, y=2)
e2 <- rlang::env(e1, a=3, b=4)
e2$a
## [1] 3
e2[["b"]]
## [1] 4
e2$x
## NULL

rlang::env_get(e2, "x")
## Error in rlang::env_get(e2, "x") : 找不到对象'x'

rlang::env_get(e2, "x", default=NA)
## [1] NA

e1 <- rlang::env(x=1, y=2)
e1$z <- 3
rlang::env_poke(e1, "a", 11)
rlang::env_bind(e1, b=12, c=13)
rlang::env_names(e1)
## [1] "x" "y" "z" "a" "b" "c"

rlang::env_has(e1, c("x", "c", "f"))
##     x     c     f 
##  TRUE  TRUE FALSE 

rlang::env_unbind(e1, c("z", "c"))
rlang::env_names(e1)
## [1] "x" "y" "a" "b"

逐层向上访问环境

要逐层向上访问环境，
可以利用R的递归函数。
下面写一个逐层向上查找指定的名字所在的环境的自定义函数。
（来自Advanced R）。

where <- function(name, env = rlang::caller_env()) {
  if (identical(env, empty_env())) {
    # 找到了顶层都没有找到
    stop("找不到 ", name, call. = FALSE)
  } else if (rlang::env_has(env, name)) {
    # 在当前的env环境中找到了，返回找到时的环境
    env
  } else {
    # 利用递归向上层查找
    Recall(name, rlang::env_parent(env))
  }
}

自变量name是要查找的名字，
env是从那个环境开始逐层向上查找，
env的缺省值是调用where()函数时的环境。
定义中分了三种情况：
到顶层（空环境）都没有找到，
出错停止；
在向上逐层查找中在某个环境中找到了，
返回找到时的环境；
否则就利用递归向上层查找。

这个例子可以用作环境逐层向上遍历的模板。

特殊环境

实际上，
一般用户都不会用到rlang::env()生成的环境；
但是用户都会接触到使用R语言时自然产生的各种环境，
只不过许多用户可能没有认识到自己是在使用环境。

R语言使用中涉及到环境的情景有：

• 扩展包的环境和搜索路径；
• 函数环境；
• 命名空间；
• 运行环境。

search()
## [1] ".GlobalEnv"        "tools:rstudio"     "package:stats"
## [4] "package:graphics"  "package:grDevices" "package:utils"
## [7] "package:datasets"  "package:methods"   "Autoloads"
## [10]"package:base"     

f1 <- function(x) 2*x
rlang::fn_env(f1)
## <environment: R_GlobalEnv>

f1 <- function(){
  times <- 0
  f2 <- function(){
    times <<- times + 1
    cat("NO. ", times, "\n", sep="")
  }
  print(rlang::fn_env(f2))
  f2
}
f2b <- f1()
## <environment: 0x00000201dc5096d8>
print(rlang::fn_env(f2b))
## <environment: 0x00000201dc5096d8>
f2b()
## NO. 1
f2b()
## NO. 2

调用栈

函数在被调用时，
还涉及到调用它的环境，
可以用rlang::caller_env()获得。
调用环境与调用时的实参计算有关，
需要了解调用栈(call stack)概念，
调用栈由若干个分层的框架(frames)组成。
R运行出错时会显示一个traceback()结果，
就是调用栈的各个框架。
如：

f1 <- function(x) {
  f2(x = 2)
}
f2 <- function(x) {
  f3(x = 3)
}
f3 <- function(x) {
  stop()
}
f1()

##  Error in f3(x = 3) : 
## 4. stop() 
## 3. f3(x = 3) 
## 2. f2(x = 2) 
## 1. f1() 

上面例子在用stop()产生出错信号时显示调用栈，
下面的函数调用了上面的函数。

可以用lobstr::cst()显示函数的调用栈。

当调用时有懒惰求值时，
调用栈就可能有多个分支。

调用栈中的每一次调用称为一个框架，
或求值上下文(evaluation context)。
框架是支持R语言的重要成分，
R程序仅能对框架数据结构作很少的操作。
每个框架有三个构成部分：

• 一个表示调用函数的表达式expr。
• 一个环境，通常是调用的函数的运行环境。
  但是，全局框架的环境还是全局环境，
  使用eval()会造出一个框架，
  其环境则是可以由用户干预的。
• 父框架，即调用它的框架。

框架还会保存函数的一些非正常执行路径，
如on.exit()指定的操作，
出错时的处理。

R采用句法作用域，
即由定义决定变量作用域，
有少数语言如Lisp采用动态作用域(dynamic scoping)，
即在调用栈上查找变量值。

将环境用作一般数据结构

环境中的变量都是引用，
或者绑定，
不需要制作环境副本，
这使得环境可以当作一种高级的数据类型使用。

将环境作为一般数据结构使用，
可以用在如下一些方面：

• 因为不需要制作副本，
  所以可以节省内存空间。
  但是直接使用环境不够友好，
  可以使用R6类型的数据，
  R6类型是建立在环境的基础上的。
• 在自己建立的扩展包中，
  用环境保存包的状态。
  这样一个包中的函数多次调用时，
  可以在多次调用之间传递一些状态信息。
  可以在包中用get.xxx()函数和set.xxx()函数提供包用户访问状态的接口函数。
• 环境可以当作一个杂凑表用，
  杂凑表可以在常数时间将名字对应到值。