GBR’s Blog

新年快乐

2019-01-01T00:00:00+00:00

#新年快乐！ #万事如意！ #恭喜发财！ #步步高升！ #一帆风顺！ #笑口常开！ #RP++！

创建R包学习教程

2018-01-16T00:00:00+00:00

Github地址：https://github.com/ShixiangWang/learn-devel-Rpkg

内容源自《R实战》第二版，酌情删改。

写在阅读之前

如果你想要的是快速构建R包骨架，推荐阅读在巨人的肩膀前行催化R包开发进行学习；如果你想了解更为基本的R包创建知识和过程，推荐阅读开发自己的R包sayHello、谢益辉写的编写R包章节以及本文创建包的文档和建立包章节。阅读一篇文档就想写好R包是远远不够的，还需要不断地实战和理解，才能融会贯通。不仅如此，一些函数和文档写法、技巧也是值得学习的，这正是本文的价值所在。

Let’s begin!

Table of Contents

## Table of Contents * [介绍](#intro) * [非参分析和npar包](#npar-pkg) * [开发包](#devel-pkg) * [创建包的文档](#document-pkg) * [建立包](#build-pkg) * [深入学习](#further-reading)

介绍

技术上，包只不过是一套函数、文档和数据的合集，以一种标准的格式保存。包让你能以一种定义良好的完整文档化方式来组织你的函数，而且便于你将程序分享给他人。

下面是几条我们可能想要创建包的理由：

让一套常用函数及其使用说明文档更加容易取用。
创造一个能解决重要分析问题（比如对缺失值的插值）的程序（一套相关函数）。

创造一个有用的包也是自我介绍和回馈R社区的好办法，R包可以直接分享或者通过CRAN和Github的在线软件库分享。

这里我们一起来学习如何从头到尾开发一个R包。我们将要开发的包名为npar，它提供非参组间比较的函数。如果结果变量是非正态或者异方差的，这套分析技术可以用来比较两组或多个组。这是分析师经常遇到的一个问题。

请使用以下代码下载包，然后保存到你现在的工作目录，接着把它安装到默认的R库当中。

pkg <- "npar_1.0.tar.gz"
loc <- "http://www.statmethods.net/RiA"
url <- paste(loc, pkg, sep="/")
download.file(url, pkg)
install.packages(pkg, repos = NULL, type = "source")

## Installing package into '/home/wangshx/R/x86_64-pc-linux-gnu-library/3.4'
## (as 'lib' is unspecified)

在接下来的内容中，我们将把npar包当做一个测试的地方，描述和展示它的功能特性和函数。然后接着我们从头开始创建包。

非参分析和npar包

非参分析是一种数据分析方法，它在传统参数分析的假设（比如正态性和同方差）不成立的情况下特别有用。这里我们会着重比较两组间或多组相互独立的数值结果变量的方法。

我们对npar包中的life数据集进行探究，它提供了对2007-2009年美国每个州65岁人的健康预期寿命（Healthy Life Expectancy, HLE）。估计值分别针对男性（hlem）和女性(hlef)。

数据集也提供了一个名为region（地区）的变量，此变量分为东北部、中北部、南部和西部。我从R标准安装中的state.region数据框中提取该变量并添加到所关注的数据集中。

假设我们想指导女性的HLE估计值是否在不同地区有显著的不同，一种方式是使用单因素方差分析，不过方差分析假设结果变量时正态分布的，并且不同地区之间的方差是同质的，让我们对这两个假设进行检查。

女性的HLE估值的分布可以用直方图来可视化。

library(npar)
hist(life$hlef, xlab="Healthy Life Expectancy (years) at Age 65",
     main="Distribution of Healthy Life Expectancy for women",
     col="grey", breaks = 10)

上图可以看出因变量是负偏的，较低的值数量较少。

不同地区的HLE分数的方差可以用并排点图来可视化：

library(ggplot2)
ggplot(data=life, aes(x=region, y=hlef)) + 
    geom_point(size=3, color="darkgrey") + 
    labs(title="Distribution of HLE Estimates by Region",
         x="US Region", y="Healthy Life Expectancy at Age 65") + 
    theme_bw()

上图中的每个点代表一个州，每个地区的方差都有所不同，东北部和南部的方差差异最大。

因此此数据不符合方差分析的两个重要假设，所以我们需要不同的分析方法。不像方差分析，非参方法不作出正态性和同方差的假设。在这个例子中，我们只需要假设数据是有序的——更高的分值意味着更高的HLE。因此，对于此问题，非参方法是一个合理的选择。

npar包比较分组

我们可以使用npar包比较独立组别的数值型因变量，至少要求它是有序的。对于数值型因变量和分类型分组变量，它提供了一下几方面功能：

综合Kruskal-Wallis检验，检验组间是否有差异。
每一组的描述性统计量
事后比较（Wilcoxon秩和检验），即每次进行两组之间的比较，检验得到的p值可以调整，以进行多重比较。
都带有注释的并排箱线图，用于可视化不同组别之间的差异。

以下代码实现了用npar包对不同地区女性的HLE估值进行比较：

library(npar)
results <- oneway(hlef ~ region, life)
summary(results)

## data: hlef on region 
## 
## Omnibus Test
## Kruskal-Wallis chi-squared = 17.8749, df = 3, p-value = 0.0004668
## 
## Descriptive Statistics
##        South North Central   West Northeast
## n      16.00         12.00 13.000     9.000
## median 13.00         15.40 15.600    15.700
## mad     1.48          1.26  0.741     0.593
## 
## Multiple Comparisons (Wilcoxon Rank Sum Tests)
## Probability Adjustment = holm
##         Group.1       Group.2    W       p   
## 1         South North Central 28.0 0.00858 **
## 2         South          West 27.0 0.00474 **
## 3         South     Northeast 17.0 0.00858 **
## 4 North Central          West 63.5 1.00000   
## 5 North Central     Northeast 42.0 1.00000   
## 6          West     Northeast 54.5 1.00000   
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

plot(results, col="lightblue", main="Multiple Comparisons",
     xlab="US Region", ylab="Healthy Life Expectancy (years) at Age 65")

首先，代码运行了一个Kruskal-Wallis检验，这是对不同地区间HLE差异的总体检验，p值0.0005指出确实存在差异。

接着，计算了每一个地区的描述性统计量，东北部HLE估值最高，南部最低；地区变化量最小的是东北部，最大的是南部。

尽管K-W检验表示不同地区的HLE有差异，但没有指出有多大的差异。若要得出此信息，需要用Wilcoxon秩和检验来成对地分组比较。对于四个组别，有4x(4-1)/2=6次比较。

南部和中北部的差异是统计上显著的（p=0.009），而东北部和中北部之间的差异并不显著（p=1.0），实际上，南部和其他地区都有所差异，但是其他地区之间的差异并不显著。

在计算多重比较的时候，必须考虑到alpha膨胀的可能性：实际上组别之间并没有显著差异，但是计算出存在差异的概率有所上升。对于六次独立的比较过程，至少有一次出错误差异的概率是$1-(1-0.05)^6$或$0.26$。

发现至少有一个错误的概率在四分之一左右，所以我们会想对每一次比较的p值进行调整，这样使得整体错误率保持在一个合理的水平（比如0.05）。

oneway()函数使用R标准安装的p.adjust()函数来完成这个功能。p.adjust()函数用很多种方法的其中一种来对多重比较的p值进行调整。尽管Bonferonni校正可能最广为人知，但是Holm校正更加强大，因此后者被设置为默认选项。

使用图形最容易看出不同组别之间的差异。plot()语句生成并排的箱线图。一条水平虚线表示所有观测值总体的中位数。

这些分析明显地指出南部女性很可能在65岁之后的预期寿命更短。这对健康服务的分布和侧重点也有所启示。你如果想分析一下男性的HLE估计值，看看是否会有类似的结论。

下一节描述了npar包的代码文件。

开发包

npar包有四个函数：oneway()、print.oneway()、summary.oneway()和plot.oneway()。第一个是主函数，计算相关的统计量；另外三个是用于输出和画图的S3面向对象泛型函数。

一个不错的办法是把每个函数分布放在扩展名为.R的不同文本文件中。尽管这不是严格要求的，但是能够使你更好地组织工作。此外、尽管并不要求函数名和文件名相同，不过这是一个好的代码习惯。

点击下方函数名可阅读文件内容：

每个文件的开头都包含了一系列以#'开头的注释。R解释器会忽略它们，不过我们可以使用roxygen2包来把这些注释转换为我们的R包文档。

oneway()函数计算相关的统计量，print()、summary()和plot()展示结果。下面我们学习开发oneway()函数。

计算统计量

oneway.R文件中的oneway()函数计算所有所需的统计量。

下面我们分段解析。

#' @title 非参组间比较
#'
#' @description
#' \code{oneway} 计算非参组间比较，包括综合检验和事后成对组间比较
#' 
#' @details
#' 这个函数计算了一个综合Kruskal-Wallis检验，用于检验组别是否相等，接着使用
#' Wilcoxon秩和检验来进行成对比较。如果因变量之间没有相互依赖的话，可以计算精确
#' 的Wilcoxon检验。使用\code{\link{p.adjust}}来对多重比较所得到的p值进行调整
#' 
#' @param formula 一个formula对象。用于表示因变量和分组变量之间的关系
#' @param data 一个包含了模型里变量的数据框
#' @param exact logical变量。如\code{TRUE}，计算精确的Wilcoxon检验
#' @param sort logical变量，如果\code{TRUE}，用因变量中位数来对组别进行排序
#' @param method 用于调整多重比较的p值的方法
#' @export
#' @return 一个有7个元素的列表
#' \item{CALL}{函数调用}
#' \item{data}{包含因变量和组间变量的数据框}
#' \item{sumstats}{包含每组的描述性统计量的数据框}
#' \item{kw}{K-W检验的结果}
#' \item{method}{用于调整p值的方法}
#' \item{wmc}{包含多重比较的数据框}
#' \item{vnames}{变量名} 
#' @author Rob Kabacoff <rkabacoff@@statmethods.net>
#' @examples
#' results <- oneway(hlef ~ region, life)
#' summary(results)
#' plot(results, col="lightblue", main="Multiple Comparisons",
#'      xlab="US Region", ylab="Healthy Life Expectancy at Age 65")

头部包含以#'开头的注释会被roxygen2包用于生成包文档。接下来你会看到列出的函数参数。用户提供一个形为因变量~分组变量的模型公式和一个包含了数据的数据框。默认会计算近似的p值并按照因变量中位数对组别排序。用户可以从八种调整p值的方法选择一种，其中holm方法（列出的第一个选项）为默认选项。

oneway <- function(formula, data, exact=FALSE, sort=TRUE,               
                method=c("holm", "hochberg", "hommel", "bonferroni",      
                         "BH", "BY", "fdr", "none")){
  ######### 检查参数 ##########
  if (missing(formula) || class(formula) != "formula" ||
        length(all.vars(formula)) != 2)                                   
       stop("'formula' is missing or incorrect")  

  method <- match.arg(method) # 参数匹配
    
    
  ######## 设定数据 ###########
  df <- model.frame(formula, data)                           
  y <- df[[1]]
  g <- as.factor(df[[2]])
  vnames <- names(df)
  
  ######## 重新排序 ############
  if(sort) g <- reorder(g, y, FUN=median)                          
  groups <- levels(g)
  k <- nlevels(g)
  
  
  ######## 计算总体统计量 ########
  getstats <- function(x)(c(N = length(x), Median = median(x),      
                          MAD = mad(x)))   
  sumstats <- t(aggregate(y, by=list(g), FUN=getstats)[2])
  rownames(sumstats) <- c("n", "median", "mad")
  colnames(sumstats) <- groups
  
  ######## 统计检验 ###########
  kw <- kruskal.test(formula, data)                          
  wmc <- NULL
  for (i in 1:(k-1)){
    for (j in (i+1):k){
      y1 <- y[g==groups[i]]
      y2 <- y[g==groups[j]] 
      test <- wilcox.test(y1, y2, exact=exact)
      r <- data.frame(Group.1=groups[i], Group.2=groups[j], 
                      W=test$statistic[[1]], p=test$p.value)
      # note the [[]] to return a single number
      wmc <- rbind(wmc, r)
    }
  }
  wmc$p <- p.adjust(wmc$p, method=method)
  
  
  data <- data.frame(y, g)                                    
  names(data) <- vnames
  results <- list(CALL = match.call(), 
                  data=data,
                  sumstats=sumstats, kw=kw, 
                  method=method, wmc=wmc, vnames=vnames)
  class(results) <- c("oneway", "list")
  return(results)
}

结果被打包并作为一个列表返回。最后该列表的类被设置为c("oneway", "list")，这是使用泛型函数处理对象的重要步骤。

尽管列表提供了所有需要的信息，但你一般不会直接获取单个分量的信息。相反，你可以创建泛型函数print()、summary()和plot()以更加具体而有意义的方法来表达它们。

打印结果

各个领域的大部分分析函数都伴随着对应的泛型函数print()和summary()。print()提供了对象的基本或原始信息，summary()提供了更加具体或处理（汇总）过的信息。如果图形在上下文中是有意义的，plot()函数也经常一起提供。

在S3面对对象中，如果一个对象有类属性”foo”，则print(x)在print.foo()函数存在时运行print.foo()，在print.foo()函数不存在时运行print.default()。summary()和plot()也有着相同的规则。因为oneway()函数返回一个类为”oneway”的对象，所以你需要定义print.oneway()、summary.oneway()和plot.oneway()函数。

对于life数据集，print(results)生成了多重比较的基本信息：

print(results)

## data: hlef by region 
## 
## Multiple Comparisons (Wilcoxon Rank Sum Tests)
## Probability Adjustment = holm
##         Group.1       Group.2    W       p
## 1         South North Central 28.0 0.00858
## 2         South          West 27.0 0.00474
## 3         South     Northeast 17.0 0.00858
## 4 North Central          West 63.5 1.00000
## 5 North Central     Northeast 42.0 1.00000
## 6          West     Northeast 54.5 1.00000

代码打印了一个有信息量的头部，接着是Wilcoxon统计量和调整后的每一对组别的p值（Group.1和Group.2）。

其源代码文件print.R内容如下：

#' @title 打印多重比较的结果
#'
#' @description
#' \code{print.oneway} 打印多重组间比较的结果
#'
#' @details
#' 这个函数打印出用 \code{\link{oneway}} 函数所创建的Wilcoxon成对多重比较的结果 
#' 
#' @param x 一个 \code{oneway}类型的变量
#' @param ... 要传输给函数的额外的变量
#' @method print oneway
#' @export
#' @return 静默返回输入的变量
#' @author Rob Kabacoff <rkabacoff@@statmethods.net>
#' @examples
#' results <- oneway(hlef ~ region, life)
#' print(results)
print.oneway <- function(x, ...){
  if (!inherits(x, "oneway"))       
    stop("Object must be of class 'oneway'")
  
  cat("data:", x$vnames[1], "by", x$vnames[2], "\n\n")  
  cat("Multiple Comparisons (Wilcoxon Rank Sum Tests)\n")
  cat(paste("Probability Adjustment = ", x$method, "\n", sep=""))
  
  print(x$wmc,  ...)
}

头部包含的以#'开头的注释会被roxygen2包生成包文档。inherits()函数用于确保被提交的对象有”oneway”这个类。一系列cat()函数打印对分析过程的描述。最后调用print.default()把多重比较打印出来。

汇总结果

与print()函数相比，summary()函数生成的输出更加全面，处理得更好。对于健康预期寿命数据，summary(results)的语句生成如下结果：

summary(results)

## data: hlef on region 
## 
## Omnibus Test
## Kruskal-Wallis chi-squared = 17.8749, df = 3, p-value = 0.0004668
## 
## Descriptive Statistics
##        South North Central   West Northeast
## n      16.00         12.00 13.000     9.000
## median 13.00         15.40 15.600    15.700
## mad     1.48          1.26  0.741     0.593
## 
## Multiple Comparisons (Wilcoxon Rank Sum Tests)
## Probability Adjustment = holm
##         Group.1       Group.2    W       p   
## 1         South North Central 28.0 0.00858 **
## 2         South          West 27.0 0.00474 **
## 3         South     Northeast 17.0 0.00858 **
## 4 North Central          West 63.5 1.00000   
## 5 North Central     Northeast 42.0 1.00000   
## 6          West     Northeast 54.5 1.00000   
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

此输出包含了K-W检验的结果、每一组的描述性统计量（样本量、中位数和绝对离差中位数）以及多重比较的结果。此外，多重比较的表格用星号来标记出显著的结果。

下方代码列出summary.oneway()函数的具体内容：

#' @title 汇总单因子非参分析的结果
#'
#' @description
#' \code{summary.oneway} 汇总了单因子非参分析的结果
#'
#' @details
#' 这个函数对\code{\link{oneway}}函数所分析的结果进行汇总并打印。这包括了每一组的
#' 描述性统计量，一个综合的Kruskal-Wallis检验的结果，以及一个Wilcoxon成对多重比较
#' 的结果
#' 
#' @param object 一个\code{oneway}类型的对象
#' @param ... 额外的参数
#' @method summary oneway
#' @export
#' @return 静默返回输入的对象
#' @author Rob Kabacoff <rkabacoff@@statmethods.net>
#' @examples
#' results <- oneway(hlef ~ region, life)
#' summary(results)
summary.oneway <- function(object, ...){
  if (!inherits(object, "oneway")) 
    stop("Object must be of class 'oneway'")
    
  if(!exists("digits")) digits <- 4L
  
  kw <- object$kw
  wmc <- object$wmc
  
  cat("data:", object$vnames[1], "on", object$vnames[2], "\n\n")
  
  ############ K-W 检验 #############
  cat("Omnibus Test\n")                        
  cat(paste("Kruskal-Wallis chi-squared = ", 
             round(kw$statistic,4), 
            ", df = ", round(kw$parameter, 3), 
            ", p-value = ", 
               format.pval(kw$p.value, digits = digits), 
            "\n\n", sep=""))
  
  #### 描述性统计量 #####
  cat("Descriptive Statistics\n")     
  print(object$sumstats, ...)
  
  #### 表格标记 ######
  wmc$stars <- " "                  
  wmc$stars[wmc$p <   .1] <- "."
  wmc$stars[wmc$p <  .05] <- "*"
  wmc$stars[wmc$p <  .01] <- "**"
  wmc$stars[wmc$p < .001] <- "***"
  names(wmc)[which(names(wmc)=="stars")] <- " "                          
  
  cat("\nMultiple Comparisons (Wilcoxon Rank Sum Tests)\n")    
  cat(paste("Probability Adjustment = ", object$method, "\n", sep=""))
  print(wmc, ...)
  cat("---\nSignif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1\n")
}

绘制结果

最后的函数plot()对oneway()函数返回的结果进行可视化：

plot(results, col="lightblue", main="Multiple Comparisons",
     xlab="US Region", ylab="Healthy Life Expectancy (years) at Age 65")

不像标准的箱线图，这幅图提供了展示每一组中位数和样本量的标记，还有一条展现出总体中位数的虚线。下面是函数的源代码：

#' @title 对非参组间比较的结果进行绘图
#'
#' @description
#' \code{plot.oneway} 对非参组间比较的结果进行绘图
#'
#' @details
#' 这个函数使用标记了的并排箱线图对\code{\link{oneway}}函数所生成的非参组间比较
#' 结果进行绘图。中位数和样本量被放置在图的上方、总体中位数用一条虚线进行表示
#' 
#' @param x 一个\code{oneway}类型的对象
#' @param ... 被传递给
#' \code{\link{boxplot}} 的额外参数
#' @method plot oneway
#' @export
#' @return NULL
#' @author Rob Kabacoff <rkabacoff@@statmethods.net>
#' @examples
#' results <- oneway(hlef ~ region, life)
#' plot(results, col="lightblue", main="Multiple Comparisons",
#'      xlab="US Region", ylab="Healthy Life Expectancy at Age 65")
plot.oneway <- function(x, ...){  

  ###### 检查输入 ##########
  if (!inherits(x, "oneway")) 
    stop("Object must be of class 'oneway'")
    
  ##### 生成箱线图 ########
  data <- x$data                                    
  y <- data[,1]
  g <- data[,2]
  stats <- x$sumstats
  lbl <- paste("md=", stats[2,], "\nn=", stats[1,], sep="")
  opar <- par(no.readonly=TRUE)
  par(mar=c(5,4,8,2))
  boxplot(y~g,  ...)
  ###### 为图添加标记 #######
  abline(h=median(y), lty=2, col="darkgray")
  axis(3, at=1:length(lbl), labels=lbl, cex.axis=.9)
  par(opar)
}

首先，要检查被传到函数的参数的类型。然后，代码提取出原始的数据，画出箱线图。接下来添加标记（中位数、样本量和总体中位数）。使用abline()来添加总体中位数那条线，使用axis()函数在图像的顶部添加中位数和样本量。

添加样本数据到包

在创建包时，加上一个或多个可用于试验所提供的数据集是一个好注意。对于npar包添加life数据库，将该数据框以.rda的文件形式添加到包里面，最后把这个文件移动到包文件树的data子文件夹里。

同时我们需要创建一个.R文件来作为此数据框的文档，代码点击life.R （此文档不再翻译，自行理解）。

创建包的文档

每个R包都符合一套对文档的强制方案。包里的每一个函数都必须使用LaTeX来以同样的风格撰写文档；LaTeX是一种文档标记语言和排版系统。每个函数都被分别放置在不同的.R文件里，函数对应的文档则被放置在一个.Rd文件中。

这种方式有两个限制。第一，文档和它所描述的函数是分开放置的。如果你改变了函数代码，就必须搜索出对应的文档并进行改写。第二，用户必须学习LaTeX，而它的学习曲线比较陡峭。

roxygen2包能够极大地简化文档的创建过程。你在每一个.R文件的头部放置一段注释作为对应的文档。然后使用一种简单的标记语言来创建文档。当Roxygen2处理文件的时候，以#'开始的行会被用来自动生成LaTeX文档（.Rd文件）。

下面描述了每个文件头部的注释所使用的标签，标签（roclet）是使用Roxygen2创建LaTeX文档的基础。

@title          函数名
@description    一行的函数描述
@details        多行的函数描述
@param          函数参数
@export         添加函数到NAMESPACE
@method generic class   泛型S3方法的文档
@return         函数返回的值
@author         作者和联系地址
@examples       使用函数的例子
@note           使用函数的注意事项
@aliases        用户能够找到文档的额外别名
@references     函数所涉及的方法的参考文档

在创建文档的时候，另外一些标记元素也很有用。标签\code{text}用代码字体把text打印出来，\link{function}创建一个指向本包或者别处函数的超级链接。最后item{text}创建一个分项列表，这对于描述函数的返回的结果特别有用。

除此之外，我们应该（这个任务是可选的）提供包的介绍文档，以便于?npar时能够找到，点击npar.R可查阅以下代码：

#' 非参组间比较的函数
#' 
#' npar提供了计算和可视化组间差异的工具
#' 
#' @docType package
#' @name npar-package
#' @aliases npar
NULL

.......这个文件必须在NULL后有一个空白行........

最后创建一个名为DESCRIPTION的文本文件用于描述包。以下是一个样例

Package: npar
Type: Package
Title: Nonparametric group comparisons
Version: 1.0
Date: 2015-01-26
Author: Rob Kabacoff
Maintainer: Robert Kabacoff <robk@statmethods.net>
Description: This package assesses group differences using nonparametric
    statistics. Currently a one-way layout is supported. Kruskal-Wallis tests
    followed by pairwise Wilcoxon tests are provided. p-values are adjusted
    for multiple comparisons using the p.adjust() function.
    Results are plotted via annotated boxplots.
LazyData: true
License: GPL-3
Packaged: 2014-11-05 19:06:44 UTC; rkabacoff
RoxygenNote: 6.0.1

DESCRIPTION部分可以包含多行，但是第一行之后的行必须缩进。lazyData:yes语句表示此包里的数据集应该在载入后尽快变得可用。如果参数设置为no用户将不得不用data(life)来获取这个数据集。

建立包

终于到了建立包的时候，开发者创建包的圣经是R核心开发团队“Writing R Extensions”。Friedrich Leishch也提供了一个创建包的优秀指南（http://mng.bz/Ks84）

以下创建包流程适用Windows、Mac以及Linux平台：

安装必要的工具。用install.packages("roxygen2", depend=TRUE)来下载和安装roxygen2包。如果使用的是Windows平台，你还需要安装Rtools.exe(https://cran.r-project.org/bin/windows/Rtools)和MiKTeX(http://miktex.org)。如果使用的是Mac，则需要安装MacTeX(http://www.tug.org/mactex)。Rtools、MiKTeX和MacTeX都不是包而是软件，因此需要在R的外部安装它们。
配置文件夹。在你的home目录下（启动R时的当前工作目录），创建一个叫作npar的子文件夹。在这个文件夹中创建两个子文件夹，分别为R和data。把DESCRIPTION文件放在npar文件夹里，并把源代码文件放在子文件夹R里。把life.rda文件放在子文件夹data里。
生成文档。加载roxygen2包，然后使用roxygenize()函数处理每一个代码文件头部文档。

library(roxygen2)
roxygenise("npar") # 可以使用npar的相对路径或绝对路径

roxygenize()函数创建一个新的子文件夹man，这个文件夹内部有与每个函数对应的.Rd文档文件。

此外，该函数对DESCRIPTION文件添加了信息，也创建了一个NAMESPACE文件。

# Generated by roxygen2: do not edit by hand

S3method(plot,oneway)
S3method(print,oneway)
S3method(summary,oneway)
export(oneway)

NAMESPACE文件控制函数的可视性：是所有函数都直接暴露给用户，还是有些函数在内部被其他函数使用？本例中所有函数都是直接对用户可用的。

建立包。用系统以下命令建立包

system("R CMD build npar")

这段代码在当前目录中创建了npar_1.0.tar.gz文件。现在这个包的格式可以分发给其他用户。

若要为Windows平台创建二进制.zip文件，可以运行以下代码：

system(Rcmd INSTALL --build npar)

注意，只有在Windows平台工作才能用这个方法。如果你不在Windows机器下运行R，但是想创建一个适用于Windows的二进制包，可以使用http://win-builder.r-project.org提供的在线服务。

检查包（可选）。要在包上运行全部的一致性检查，可以运行以下代码：

system("R CMD check npar")

如果你想分发你的包到CRAN上，检查结果必须是没有任何错误和警告的。

创建一个PDF手册（可选）。运行：

system("R CMD Rd2pdf npar")

创建一本类似于你在CRAN上看到的PDF参考手册。

本地安装包（可选）。运行语句

system("R CMD INSTALL npar")

在你的机器上安装这个包，另一个本地安装包的方法是使用

install.packages("./npar_1.0.tar.gz", repos=NULL, type="source")

在开发周期中，你也许想从本地机器删除一个包从而能够安装一个新的版本。这种情况下，用代码：

detach(package:npar, unload=TRUE)
remove.packages("npar")

来得到一个全新的开始。

上传包到CRAN（可选），如果你想把包添加到CRAN库从而分享给他人，只需要进行以下三步：
- 阅读CRAN库的政策（http://cran.r-project.org/web/packages/policies.html）。
- 确保包通过了步骤5的所有检查，没有任何错误和警告。不然包会被拒绝接受。
- 提交包。可以使用http://cran.r-project.org/submit.html中用于提交的表单。你会收到一个自动确认的电子邮件，你需要接受它。

深入学习

大部分包所包含的代码都是完全用R完成的，不过你也可以在R中调用编译后的C、C++、Fortran和Java代码。引入外来代码的典型情况是希望以此来提升运行速度，或者作者想在R代码中使用现有的外部软件库。

有很多种方法可以引入编译后的外部代码，有用的函数包括.C()、Fortran()、External()和.Call()等。还有一些包的创造是为了简化流程，比如inline（C、C++、Fortran）、Rcpp(C++)和rJava(Java)。

为R包添加外部的编译后代码参考“Writing R Extensions”以及相关函数和包的帮助文件。

初识sed与awk

2017-12-25T00:00:00+00:00

学习内容：

学习sed编辑器

gawk编辑器入门

sed编辑器基础

shell脚本最常见的一个用途就是处理文本文件，但仅靠shell脚本命令来处理文本文件的内容有点勉为其难。如果我们想在shell脚本中处理任何类型的数据，需要熟悉Linux中的sed和gawk工具。这两个工具可以极大简化我们需要进行的数据处理任务。

文本处理

当我们需要自动处理文本文件，又不想动用交互式文本编辑器时，sed和gawk是我们最好的选择。

sed编辑器

也被称为流编辑器（stream editor），会在编辑器处理数据之前基于预先提供的一组规则来编辑数据流。

sed编辑器可以根据命令来处理数据流中的数据，这些命令既可以从终端输入，也可以存储进脚本文件中。

sed会执行以下的操作：

一次从输入中读取一行数据
根据所提供的命令匹配数据
按照命令修改流中的数据
将新的数据输出到STDOUT

这一过程会重复直至处理完流中的所有数据行。

sed命令的格式如下：

sed options script file

选项options可以允许我们修改sed命令的行为

选项	描述
-e script	在处理输入时，将script中指定的命令添加到已有的命令中
-f file	在处理输入时，将file中指定的命令添加到已有的命令中
-n	不产生命令输出，使用`print`命令来完成输出

script参数指定用于流数据上的单个命令，如果需要多个命令，要么使用-e选项在命令行中指定，要么使用-f选项在单独的文件中指定。

在命令行中定义编辑器命令

默认sed会将指定命令应用到STDIN输入流上，我们可以配合管道命令使用。

wsx@wsx-laptop:~/tmp$ echo "This is a test" | sed 's/test/big test/'
This is a big test

s命令使用斜线间指定的第二个文本来替换第一个文本字符串模式（注意是替换整个模式，支持正则匹配），比如这个例子用big test替换了test。

假如有以下文本：

wsx@wsx-laptop:~/tmp$ cat data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.

键入命令，查看输出

wsx@wsx-laptop:~/tmp$ sed 's/dog/cat/' data1.txt
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.

可以看到符合模式的字符串都被修改了。

要记住，sed并不会修改文本文件的数据，它只会将修改后的数据发送到STDOUT。

在命令行上使用多个编辑器命令

使用-e选项可以执行多个命令

wsx@wsx-laptop:~/tmp$ sed -e 's/brown/green/; s/dog/cat/' data1.txt
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.
The quick green fox jumps over the lazy cat.

两个命令都作用到文件中的每一行数据上。命令之间必须用分号隔开，并且在命令末尾与分号之间不同有空格。

如果不想使用分号，可以用bash shell中的次提示符来分隔命令。

wsx@wsx-laptop:~/tmp$ sed -e '
> s/brown/green/
> s/fox/elephant/
> s/dog/cat/' data1.txt
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.

从文件中读取编辑器命令

如果有大量要处理的sed命令，将其单独放入一个文本中会更方便，可以用sed命令的-f选项来指定文件。

wsx@wsx-laptop:~/tmp$ cat script1.sed
s/brown/green/
s/fox/elephant/
s/dog/cat/

wsx@wsx-laptop:~/tmp$ sed -f script1.sed data1.txt
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.
The quick green elephant jumps over the lazy cat.

这种情况不用在每个命令后面放一个分号，sed知道每行都有一条单独的命令。

gawk程序

gawk是一个处理文本的更高级工具，能够提供一个类编程环境来修改和重新组织文件中的数据。

说明	在所有的发行版都没有默认安装gawk程序，请先安装

gawk程序是Unix中原始awk的GNU版本，它让流编辑器迈上了一个新的台阶，提供了一种编程语言而不只是编辑器命令。

我们可以利用它做下面的事情：

定义变量来保存数据
使用算术和字符串操作符来处理数据
使用结构化编程概念来为数据处理增加处理逻辑
通过提取数据文件中的数据元素，将其重新排列或格式化，生成格式化报告

gawk程序的报告生成能力通常用来从大文本文件中提取数据元素，并将它们格式化成可读的报告，使得重要的数据更易于可读。

基本命令格式

gawk options program file

下面显示了gawk程序的可用选项

选项	描述
-F fs	指定行中划分数据字段的字段分隔符
-f file	从指定文件中读取程序
-v var=value	定义gawk程序中的一个变量及其默认值
-mf N	指定要处理的数据文件中的最大字段数
-mr N	指定数据文件中的最大数据行数
-W keyword	指定gawk的兼容模式或警告等级

gawk的强大之处在于程序脚本（善于利用工具最强之处），可以写脚本来读取文本行的数据，然后处理并显示数据，创建任何类型的输出报告。

从命令行读取脚本

我们必须将脚本命令放入两个花括号中，而由于gawk命令行假定脚本是单个文本字符串，所以我们必须把脚本放到单引号中。

下面是一个简单的例子：

wsx@wsx-laptop:~/tmp$ gawk '{print "Hello World!"}'

Hello World!
This is a test
Hello World!
This is
Hello World!

Hello World!

print命令将文本打印到STDOUT。如果尝试允许命令，我们可能会有些失望，因为什么都不会发生，原因是没有指定文件名，所以gawk会从STDIN接收数据，如果我们按下回车，gawk会对这行文本允许一遍程序脚本。

要终止这个程序必须表明数据流已经结束了，bash shell提供组合键来生成EOF(End-of-File)字符。Ctrl+D组合键会在bash中产生一个EOF字符。

使用数据字段变量

gawk的主要特性之一是其处理文本文件中数据的能力，它自动给一行的每个数据元素分配一个变量。

$0代表整个文本行
$1代表文本行的第一个数据字段
$2代表文本行的第二个数据字段
$n代表文本行的第n个数据字段

gawk在读取一行文本时，会用预定义的字段分隔符划分每个数据字段。默认字段分隔符为任意的空白字符（例如空格或制表符）。

下面例子gawk读取文本显示第一个数据字段的值。

wsx@wsx-laptop:~/tmp$ cat data2.txt
One line of test text.
Two lines of test text.
Three lines of test text.
wsx@wsx-laptop:~/tmp$ gawk '{print $1}' data2.txt
One
Two
Three

我们可以使用-F选项指定其他字段分隔符：

wsx@wsx-laptop:~/tmp$ gawk -F: '{print $1}' /etc/passwd
root
daemon
bin
sys
sync
games
man
lp
mail
news
uucp
proxy
www-data
backup
...

这个简短程序显示了系统中密码文件的第一个数据字段。

在程序脚本中使用多个命令

在命令之间放个分号即可。

wsx@wsx-laptop:~/tmp$ echo "My name is Shixiang" | gawk '{$4="Christine"; print $0}'
My name is Christine

也可以使用次提示符一次一行输入程序脚本命令（类似sed）。

从文件中读取程序

wsx@wsx-laptop:~/tmp$ cat script2.gawk
{print $1 " 's home directory is " $6}
wsx@wsx-laptop:~/tmp$ gawk -F: -f script2.gawk  /etc/passwd
root 's home directory is /root
daemon 's home directory is /usr/sbin
bin 's home directory is /bin
sys 's home directory is /dev
sync 's home directory is /bin
games 's home directory is /usr/games
man 's home directory is /var/cache/man
lp 's home directory is /var/spool/lpd
mail 's home directory is /var/mail
news 's home directory is /var/spool/news
uucp 's home directory is /var/spool/uucp
proxy 's home directory is /bin
...

可以在程序文件中指定多条命令：

wsx@wsx-laptop:~/tmp$ cat script3.gawk
{
text = "'s home directory is "
print $1 text $6
}
wsx@wsx-laptop:~/tmp$ gawk -F: -f script3.gawk /etc/passwd
root's home directory is /root
daemon's home directory is /usr/sbin
bin's home directory is /bin
sys's home directory is /dev
sync's home directory is /bin
games's home directory is /usr/games
man's home directory is /var/cache/man
lp's home directory is /var/spool/lpd
mail's home directory is /var/mail
news's home directory is /var/spool/news
...

在处理数据前运行脚本

使用BEGIN关键字可以强制gawk再读取数据前执行BEGIN关键字指定的程序脚本。

wsx@wsx-laptop:~/tmp$ cat data3.txt
Line 1
Line 2
Line 3
wsx@wsx-laptop:~/tmp$ gawk 'BEGIN {print "The data3 File Contents:"}
> {print $0}' data3.txt
The data3 File Contents:
Line 1
Line 2
Line 3

在gawk执行了BEGIN脚本后，它会用第二段脚本来处理文件数据。

在处理数据后允许脚本

与BEGIN关键字类似，END关键字允许我们指定一个脚本，gawk在读完数据后执行。

wsx@wsx-laptop:~/tmp$ gawk 'BEGIN {print "The data3 File Contents:"}
> {print $0}
> END {print "End of File"}' data3.txt
The data3 File Contents:
Line 1
Line 2
Line 3
End of File

我们把所有的内容放在一起组成一个漂亮的小程序脚本，用它从简单的数据文件中创建一份完整报告。

wsx@wsx-laptop:~/tmp$ cat script4.gawk
BEGIN {
print "The latest list of users and shells"
print " UserID \t Shell"
print "-------- \t ------"
FS=":"
}

{
print $1 "      \t " $7
}

END {
print "This concludes the listing"
}
wsx@wsx-laptop:~/tmp$ gawk -f script4.gawk /etc/passwd
The latest list of users and shells
 UserID          Shell
--------         ------
root             /bin/bash
daemon           /usr/sbin/nologin
bin              /usr/sbin/nologin
sys              /usr/sbin/nologin
sync             /bin/sync
games            /usr/sbin/nologin
man              /usr/sbin/nologin
lp               /usr/sbin/nologin
mail             /usr/sbin/nologin
news             /usr/sbin/nologin
uucp             /usr/sbin/nologin
proxy            /usr/sbin/nologin
www-data         /usr/sbin/nologin
backup           /usr/sbin/nologin
list             /usr/sbin/nologin
irc              /usr/sbin/nologin
gnats            /usr/sbin/nologin
nobody           /usr/sbin/nologin
systemd-timesync         /bin/false
systemd-network          /bin/false
systemd-resolve          /bin/false
systemd-bus-proxy        /bin/false
syslog           /bin/false
_apt             /bin/false
lxd              /bin/false
messagebus               /bin/false
uuidd            /bin/false
dnsmasq          /bin/false
sshd             /usr/sbin/nologin
pollinate        /bin/false
wsx              /bin/bash
This concludes the listing

我们以后会继续学习gawk高级编程。

sed编辑器基础

下面介绍一些可以集成到脚本中的基本命令和功能。

使用地址

如果只想要命令作用于特定行或某些行，必须使用行寻址。

有两种形式：

以数字形式表示行区间
用文本模式来过滤出行

它们都使用相同地格式来指定地址：

[address]command

也可以将多个命令分组

address {
  command1
  command2
  command3
}

以数字的方式行寻址

sed编辑器会将文本流中的第一行编号为1，然后继续按顺序给以下行编号。

指定的地址可以是单个行号，或者用行号、逗号以及结尾行号指定的一定区间范围的行。

wsx@wsx-laptop:~/tmp$ cat data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
wsx@wsx-laptop:~/tmp$ sed '2s/dog/cat/' data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
wsx@wsx-laptop:~/tmp$ sed '2,3s/dog/cat/' data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
wsx@wsx-laptop:~/tmp$ sed '2,$s/dog/cat/' data1.txt  # 美元符指代最后一行
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.
The quick brown fox jumps over the lazy cat.

使用文本模式过滤器

sed允许指定文本模式来过滤出命令要作用的行，格式如下：

/pattern/command

比如我要修改默认的shell，可以使用sed命令：

wsx@wsx-laptop:~/tmp$ grep wsx /etc/passwd
wsx:x:1000:1000:"",,,:/home/wsx:/bin/bash
wsx@wsx-laptop:~/tmp$ grep '/wsx/s/bash/csh/' /etc/passwd
wsx@wsx-laptop:~/tmp$ sed '/wsx/s/bash/csh/' /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
...
wsx:x:1000:1000:"",,,:/home/wsx:/bin/csh

正则表达式允许创建高级文本模式匹配表达式来匹配各种数据，结合一系列通配符、特殊字符来生成几乎任何形式文本的简练模式。我们后续会学习到。

命令组合

使用花括号可以将多条命令组合在一起。

wsx@wsx-laptop:~/tmp$ sed '2{
> s/fox/elephant/
> s/dog/cat/
> }' data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown elephant jumps over the lazy cat.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.

也可以在一组命令前指定一个地址区间。

wsx@wsx-laptop:~/tmp$ sed '3,${
s/brown/green/
s/lazy/active/
}' data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.
The quick green fox jumps over the active dog.

删除行

如果需要删除文本流中的特定行，使用删除命令d，它会删除匹配指定寻址模式的所有行。使用时要特别小心，如果忘记加入寻址模式，会将所有文本行删除。

wsx@wsx-laptop:~/tmp$ cat data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
wsx@wsx-laptop:~/tmp$ sed 'd' data1.txt

和指定的地址一起使用才能发挥删除命令的最大功用。

wsx@wsx-laptop:~/tmp$ cat data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
wsx@wsx-laptop:~/tmp$ sed '3d' data6.txt
This is line number 1.
This is line number 2.
This is line number 4.

通过特定行区间指定：

wsx@wsx-laptop:~/tmp$ sed '2,3d' data6.txt
This is line number 1.
This is line number 4.

通过特殊文本结尾字符指定：

wsx@wsx-laptop:~/tmp$ sed '2,$d' data6.txt
This is line number 1.

还可以使用模式匹配特性：

wsx@wsx-laptop:~/tmp$ sed '/number 1/d' data6.txt
This is line number 2.
This is line number 3.
This is line number 4.

sed会删除包含匹配模式的行。

记住，sed不会修改原始文件。

还可以使用两个文本模式来删除某个区间内的行，但做的时候需要特别小心，指定的第一个模式会“打开”行删除功能，第二个模式会“关闭”行删除功能。sed会删除两个指定行之间的所有行（包括指定行）。

wsx@wsx-laptop:~/tmp$ cat data7.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
This is line number 1 again.
This is text you want to keep.
This is the last line in the file.
wsx@wsx-laptop:~/tmp$ sed '/1/,/3/d' data7.txt
This is line number 4.

第二个出现的数字“1”的行再次触发了删除命令，因为未能找到停止模式“3”，所以将数据流剩余的行全部删掉了。

wsx@wsx-laptop:~/tmp$ sed '/1/,/5/d' data7.txt
wsx@wsx-laptop:~/tmp$ sed '/2/,/4/d' data7.txt
This is line number 1.
This is line number 1 again.
This is text you want to keep.
This is the last line in the file.

插入和附加文本

sed允许向数据流插入和附加文本行：

插入命令i会在指定行前增加一个新行
附加命令a会在指定行后增加一个新行

注意，它们不能在单个命令行上使用，必须要指定是要插入还是要附加到的那一行。

wsx@wsx-laptop:~/tmp$ echo "Test Line 2" | sed 'i\Test Line 1'
Test Line 1
Test Line 2
wsx@wsx-laptop:~/tmp$ echo "Test Line 2" | sed 'a\Test Line 1'
Test Line 2
Test Line 1

要向数据流行内部插入或附加数据，必须用寻址来告诉sed数据应该出现在什么位置。

wsx@wsx-laptop:~/tmp$ sed '3i\ This is an inserted line.' data6.txt
This is line number 1.
This is line number 2.
 This is an inserted line.
This is line number 3.
This is line number 4.
wsx@wsx-laptop:~/tmp$ sed '3a\ This is an inserted line.' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
 This is an inserted line.
This is line number 4.

如果想要给数据流末尾添加多行数据，通过$指定位置即可。

This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
 This is a new line.

修改行

修改（change）命令允许修改整个数据流中整行文本内容。它跟插入和附加命令的工作机制一样。

wsx@wsx-laptop:~/tmp$ sed '3c\This is a changed line.' data6.txt
This is line number 1.
This is line number 2.
This is a changed line.
This is line number 4.
wsx@wsx-laptop:~/tmp$ sed '/number 3/c\This is a changed line.' data6.txt
This is line number 1.
This is line number 2.
This is a changed line.
This is line number 4.

转换命令

转换命令（y）是唯一可以处理单字符的sed命令。格式如下：

[address]y/inchars/outchars

转换命令会对inchars和outchars值进行一对一的映射。如果两者字符长度不同，则sed产生一条错误信息。

wsx@wsx-laptop:~/tmp$ sed 'y/123/789/' data6.txt
This is line number 7.
This is line number 8.
This is line number 9.
This is line number 4.

转换命令是一个全局命令，它会在文本行中找到的所有指定字符自动进行转换，而不会考虑它们出现的位置。

回顾命令

另有3个命令可以用来打印数据流中的信息：

p命令用来打印文本行
等号=命令用来打印行号
l用来列出行

打印行

wsx@wsx-laptop:~/tmp$ echo "this is a test" | sed 'p'
this is a test
this is a test

p打印已有的数据文本。最常用的用法是打印符合匹配文本模式的行。

wsx@wsx-laptop:~/tmp$ cat data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
wsx@wsx-laptop:~/tmp$ sed -n '/number 3/p' data6.txt
This is line number 3.

在命令行上使用-n选项，可以禁止输出其他行，只打印包含匹配文本模式的行。

也可以用来快速打印数据流中的某些行：

wsx@wsx-laptop:~/tmp$ sed -n '2,3p' data6.txt
This is line number 2.
This is line number 3.

打印行号

wsx@wsx-laptop:~/tmp$ cat data1.txt
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.
wsx@wsx-laptop:~/tmp$ sed '=' data1.txt
1
The quick brown fox jumps over the lazy dog.
2
The quick brown fox jumps over the lazy dog.
3
The quick brown fox jumps over the lazy dog.
4
The quick brown fox jumps over the lazy dog.
5
The quick brown fox jumps over the lazy dog.
6
The quick brown fox jumps over the lazy dog.
7
The quick brown fox jumps over the lazy dog.
8
The quick brown fox jumps over the lazy dog.
9
The quick brown fox jumps over the lazy dog.

这用来查找特定文本模式的话非常方便：

wsx@wsx-laptop:~/tmp$ sed -n '/number 4/{
> =
> p
> }' data6.txt
4
This is line number 4.

列出行

wsx@wsx-laptop:~/tmp$ cat data9.txt
This    line    contains        tabs.
wsx@wsx-laptop:~/tmp$ sed -n 'l' data9.txt
This\tline\tcontains\ttabs.$

使用Sed处理文件

写入文件

w命令用来向文件写入行。该命令格式如下：

[address]w filename

将文本的前两行写入其他文件：

wsx@wsx-laptop:~/tmp$ sed '1,2w test.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
wsx@wsx-laptop:~/tmp$ cat test.txt
This is line number 1.
This is line number 2.

如果不想让行显示到STDOUT（因为sed默认数据文本流），可以使用sed命令的-n选项。

读取数据

读取命令为r。

wsx@wsx-laptop:~/tmp$ cat data12.txt
This is an added line.
This is the second added line.
wsx@wsx-laptop:~/tmp$ sed '3r data12.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is an added line.
This is the second added line.
This is line number 4.

这效果有点像插入文本命令i和补充命令a。

同样适用于文本模式地址：

wsx@wsx-laptop:~/tmp$ sed '/number 2/r data12.txt' data6.txt
This is line number 1.
This is line number 2.
This is an added line.
This is the second added line.
This is line number 3.
This is line number 4.

文本末尾添加：

wsx@wsx-laptop:~/tmp$ sed '$r data12.txt' data6.txt
This is line number 1.
This is line number 2.
This is line number 3.
This is line number 4.
This is an added line.
This is the second added line.

读取命令的一个很酷的用法是和删除命令配合使用：利用另一个文件中的数据来替换文件中的占位文本。假如你有一份套用信件保存在文本中：

wsx@wsx-laptop:~/tmp$ cat notice.std
Would the following people:
LIST
please report to the ship's captain.

套用信件将通用占位文本LIST放在人物名单的位置，我们先根据它插入文本字符，然后删除它。

wsx@wsx-laptop:~/tmp$ sed '/LIST/{
> r data10.txt
> d
> }' notice.std
Would the following people:
This line contains an escape character.
please report to the ship's captain.
wsx@wsx-laptop:~/tmp$ cat data10.txt
This line contains an escape character.
wsx@wsx-laptop:~/tmp$ cat data11.txt
wangshx zhdan
wsx@wsx-laptop:~/tmp$ sed '/LIST/{
r data11.txt
d
}' notice.std
Would the following people:
wangshx zhdan
please report to the ship's captain.

可以看到占位符被替换成了数据文件中的文字。

完。

重复计算研究的十条简单规则

2017-12-19T00:00:00+00:00

文献来源：Ten Simple Rules for Reproducible Computational Research

我们在这里提出针对计算分析研究重复性的十条简单规则。这些规则的使用可以根据自己的研究情况进行调整。

Rule 1：记录每一个结果是如何产生的

当一个结果可能有潜在价值的时候，确保记录它是如何产生的。计算分析涉及多个连续的步骤，大量的中间步骤（简单命令、脚本、软件）、结果，无论是自动处理还是手动处理，我们都称这一系列步骤为分析流程。对于其中的每一步，你要确保可能会影响结果的步骤详情都被记录。如果分析是通过计算机软件执行的，一定要记录软件的名字、版本号以及输入使用的参数。虽然我们可以人工地记录处理的每一个步骤，写进说明文档，但它非常容易和我们最后使用的版本失去同步，从而导致无法重现结果。与其提供全部流程的分析说明文档，不如让分析流程可以直接执行重现，这样无论是自己还是他人都可以自动实现重复，这需要利用一些可执行的描述——脚本、编译文件或者存储在工作流程管理系统中的工作流程记录（GenePattern, Galaxy等）。

最低限度你也至少要充分地记录软件、参数以及手动处理过程的详情保证你在一年左右能够重复结果。

Rule 2：避免手动的数据操作步骤

尽可能地依赖软件而不是手动地对数据操作，手动操作不仅效率低而且容易出错、难以重复。如果手动操作不可避免，也要记录对哪些文件进行了移动和修改，为了什么目的。

Rule 3：对所有的外部软件版本进行存档

为了能够精确重复一个既定的结果，使用数据处理时对应的原始版本是非常有必要的。对于同一个软件不同的版本，输入输出可能会改变，而使用原始版本可以不用做任何修改。除此之外，数据处理可能会用到多种软件，而它们之间可能有版本依赖，所以对使用的软件版本进行记录或存档方便重复。为了确保使用软件未来的可用性，一种可用的策略是将软件和系统保存为虚拟镜像。

Rule 4：所有自定义脚本的版本控制

即使使用相同的参数与数据，对程序（自定义的脚本）的轻微的改动都有可能导致不可估量的后果，使得分析不可重现。标准的解决方案是用版本控制系统记录你代码的演变，比如Subversion，Git等。这些系统都简单易用，而且支持多平台，可以在整个开发过程中系统性地记录和存储代码的及其状态。

最低限度也要时时对脚本拷贝和存档。

Rule 5：记录所有的中间结果，可能情况下使用标准文件格式

原理上只要记录了得到既定结果的所有的处理流程，所有相应中间结果也能够重现。而实际操作中，如果做到非常容易获取中间结果将会非常有价值。快速浏览中间结果可以揭示与假定之间的差异，发现bug和错误的揭示，而这通常在最后的结果中看不出来；其次，更能直观显示每一步备用程序和参数的结果；第三点，如果全部的流程不能执行，可以执行一部分；第四点，重复结果时可以追踪记录到出错或有问题的那一步；第五，可以针对某一个结果进行关键性的检查而不用所有的步骤都可执行。最低限度，在存储空间允许的情况下，对分析产生的任何中间结果进行存档。

Rule 6：对于包含随机性的分析，记录设定的随机种子

有些分析和预测可能包含随机的元素，这意味着相同的程序每次执行结果可能会有所不同。一般程序软件都提供了设定随机种子功能，确保在进行相关分析时使用并记录。最低限度也要记录哪些步骤涉及了随机性分析。

Rule 7：总是存储绘图使用的原始数据

发表文章难免要多次修改图形，但大多数情况图形使用的原始数据是一致的，所以存储它有利于自己重复修改图形和创建新的图形，而不要重复整个分析，增加出错的可能。

Rule 8：生成分层的分析输出，允许对增加的细节进行检查

在文章中使用的最后结果可能是图形或表格，通常是高度总结的数据。当存储环境允许条件下，最好在生成主要结果时将所有底层数据的永久输出合并起来。一般而言，我们发现超文本文件html非常有用。当处理总结性的结果时，你至少应该做过一次生成、检查和研究总结中的具体数值。

Rule 9：将文本报告连接到底层结果

大致意思是一个典型的研究项目会有结果的大量不同分析和文本解释说明。结果通常在服务器或个人电脑的数据区域，而文本解释则经常在个人笔记、或与同事的邮件中。如果我们想要重新评估之前的解释或者允许你的同行自己进行评估，你需要将给定的文本说明（解释、声明、总结）与支持它的精确结果（图、表）连接起来。这个过程非常难或者容易出错，所以我们建议将文本报告连接到底层结果。它可以是指向具体结果的文件路径；或者是分析框架中结果的ID。

最低限度，你也应该提供充分的文本解释，保证未来也以追踪到它指向的部分结果。

Rule 10：提供脚本、运行和结果的公共存取

（没啥好说的，就是公开你的分析及结果）

学习git

2017-12-08T00:00:00+00:00

纯属搬砖操作，资料来源《Github入门与实战》，这本书的重要信息也就这些了，需要的时候找一找。

书上提到的一个学习网站https://learngitbranching.js.org/非常棒，线上学习。

Git基本操作

git init——初始化仓库

$ mkdir git-tutorial
$ cd git-tutorial
$ git init
Initialized empty Git repository in /Users/hirocaster/github/github-book
/git-tutorial/.git/

如果初始化成功，执行了 git init命令的目录下就会生成 .git 目录。这个 .git 目录里存储着管理当前目录内容所需的仓库数据。在 Git 中，我们将这个目录的内容称为“附属于该仓库的工作树”。文件的编辑等操作在工作树中进行，然后记录到仓库中，以此管理文件的历史快照。如果想将文件恢复到原先的状态，可以从仓库中调取之前的快照，在工作树中打开。

git status——查看仓库状态

git status命令用于显示 Git 仓库的状态。这是一个十分常用的命令，请务必牢记。

工作树和仓库在被操作的过程中，状态会不断发生变化。在 Git 操作过程中时常用 git status命令查看当前状态，可谓基本中的基本。下面，就让我们来实际查看一下当前状态：

$ git status
# On branch master
#
# Initial commit
#
nothing to commit (create/copy files and use "git add" to track)

结果显示了我们当前正处于 master 分支下。关于分支我们会在不久后讲到，现在不必深究。接着还显示了没有可提交的内容。所谓提交（Commit），是指“记录工作树中所有文件的当前状态”。

git add——向暂存区中添加文件

要想让文件成为 Git 仓库的管理对象，就需要用 git add命令将其加入暂存区（Stage 或者 Index）中。暂存区是提交之前的一个临时区域。

$ git add README.md
$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
# (use "git rm --cached <file>..." to unstage)
#
# new file: README.md
#

将 README.md 文件加入暂存区后， git status命令的显示结果发生了变化。可以看到， README.md 文件显示在 Changes to be committed 中了。

git commit——保存仓库的历史记录

git commit命令可以将当前暂存区中的文件实际保存到仓库的历史记录中。通过这些记录，我们就可以在工作树中复原文件。

$ git commit -m "First commit"
[master (root-commit) 9f129ba] First commit
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 README.md

-m 参数后的 “First commit”称作提交信息，是对这个提交的概述。

git log——查看提交日志

git log命令可以查看以往仓库中提交的日志。包括可以查看什么人在什么时候进行了提交或合并，以及操作前后有怎样的差别。关于合并我们会在后面解说。

我们先来看看刚才的 git commit命令是否被记录了。

$ git log
commit 9f129bae19b2c82fb4e98cde5890e52a6c546922
Author: hirocaster <hohtsuka@gmail.com>
Date: Sun May 5 16:06:49 2013 +0900
First commit

如上图所示，屏幕显示了刚刚的提交操作。 commit 栏旁边显示的“9f129b……”是指向这个提交的哈希值。 Git 的其他命令中，在指向提交时会用到这个哈希值。

Author 栏中显示我们给 Git 设置的用户名和邮箱地址。 Date 栏中显示提交执行的日期和时间。再往下就是该提交的提交信息。

只显示提交信息的第一行

如果只想让程序显示第一行简述信息，可以在 git log命令后加上 –pretty=short。这样一来开发人员就能够更轻松地把握多个提交。

只显示指定目录、文件的日志

只要在 git log命令后加上目录名，便会只显示该目录下的日志。如果加的是文件名，就会只显示与该文件相关的日志。

显示文件的改动

如果想查看提交所带来的改动，可以加上 -p参数，文件的前后差别就会显示在提交信息之后。

$ git log -p

如上所述， git log命令可以利用多种参数帮助开发者把握以往提交的内容。不必勉强自己一次记下全部参数，每当有想查看的日志就积极去查，慢慢就能得心应手了。

git diff——查看更改前后的差别

git diff命令可以查看工作树、暂存区、最新提交之间的差别。单从字面上可能很难理解，各位不妨跟着笔者的解说亲手试一试。

查看工作树和暂存区的差别

$ git diff
diff --git a/README.md b/README.md
index e69de29..cb5dc9f 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1 @@
+# Git教程

这里解释一下显示的内容。“+”号标出的是新添加的行，被删除的行则用“-”号标出。我们可以看到，这次只添加了一行。

查看工作树和最新提交的差别

要查看与最新提交的差别，请执行以下命令。

$ git diff HEAD
diff --git a/README.md b/README.md
index e69de29..cb5dc9f 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1 @@
+# Git教程

不妨养成这样一个好习惯：在执行 git commit命令之前先执行git diff HEAD命令，查看本次提交与上次提交之间有什么差别，等确认完毕后再进行提交。这里的 HEAD 是指向当前分支中最新一次提交的指针。

分支操作

通过灵活运用分支，可以让多人同时高效地进行并行开发。在这里，我们将带大家学习与分支相关的 Git 操作。

git branch——显示分支一览表

git branch命令可以将分支名列表显示，同时可以确认当前所在分支。让我们来实际运行 git branch命令。

$ git branch
* master

可以看到 master 分支左侧标有“*”（星号），表示这是我们当前所在的分支。也就是说，我们正在 master 分支下进行开发。结果中没有显示其他分支名，表示本地仓库中只存在 master 一个分支。

git checkout -b——创建、切换分支

如果想以当前的 master 分支为基础创建新的分支，我们需要用到git checkout -b命令。

切换到 feature-A 分支并进行提交

执行下面的命令，创建名为 feature-A 的分支。

$ git checkout -b feature-A
Switched to a new branch 'feature-A'

实际上，连续执行下面两条命令也能收到同样效果。

$ git branch feature-A
$ git checkout feature-A

创建 feature-A 分支，并将当前分支切换为 feature-A 分支。这时再来查看分支列表，会显示我们处于 feature-A 分支下。

$ git branch
* feature-A
master

feature-A 分支左侧标有“*”，表示当前分支为 feature-A。在这个状态下像正常开发那样修改代码、执行 git add命令并进行提交的话，代码就会提交至 feature-A 分支。像这样不断对一个分支（例如feature-A）进行提交的操作，我们称为“培育分支”。

切换回上一个分支

$ git checkout -

像上面这样用“-”（连字符）代替分支名，就可以切换至上一个分支。

特性分支

Git 与 Subversion（SVN）等集中型版本管理系统不同，创建分支时不需要连接中央仓库，所以能够相对轻松地创建分支。因此，当今大部分工作流程中都用到了特性（Topic）分支。

特性分支顾名思义，是集中实现单一特性（主题），除此之外不进行任何作业的分支。在日常开发中，往往会创建数个特性分支，同时在此之外再保留一个随时可以发布软件的稳定分支。稳定分支的角色通常由 master 分支担当。

基于特定主题的作业在特性分支中进行，主题完成后再与 master 分支合并。只要保持这样一个开发流程，就能保证 master 分支可以随时供人查看。这样一来，其他开发者也可以放心大胆地从 master 分支创建新的特性分支。

git merge——合并分支

接下来，我们假设 feature-A 已经实现完毕，想要将它合并到主干分支 master 中。首先切换到 master 分支。

$ git checkout master
Switched to branch 'master'

然后合并 feature-A 分支。为了在历史记录中明确记录下本次分支合并，我们需要创建合并提交。因此，在合并时加上 –no-ff参数。

$ git merge --no-ff feature-A

随后编辑器会启动，用于录入合并提交的信息。

git log –graph——以图表形式查看分支

用 git log –graph命令进行查看的话，能很清楚地看到特性分支（feature-A）提交的内容已被合并。除此以外，特性分支的创建以及合并也都清楚明了。

$ git log --graph
* commit 83b0b94268675cb715ac6c8a5bc1965938c15f62
|\ Merge: fd0cbf0 8a6c8b9
| | Author: hirocaster <hohtsuka@gmail.com>
| | Date: Sun May 5 16:37:57 2013 +0900
| |
| | Merge branch 'feature-A'
| |
| * commit 8a6c8b97c8962cd44afb69c65f26d6e1a6c088d8
|/ Author: hirocaster <hohtsuka@gmail.com>
| Date: Sun May 5 16:22:02 2013 +0900
|
| Add feature-A
|
* commit fd0cbf0d4a25f747230694d95cac1be72d33441d
| Author: hirocaster <hohtsuka@gmail.com>
| Date: Sun May 5 16:10:15 2013 +0900
|
| Add index
|
* commit 9f129bae19b2c82fb4e98cde5890e52a6c546922
Author: hirocaster <hohtsuka@gmail.com>
Date: Sun May 5 16:06:49 2013 +0900
First commit

git log –graph命令可以用图表形式输出提交日志，非常直观，请大家务必记住。

更改提交的操作

git reset——回溯历史版本

Git 的另一特征便是可以灵活操作历史版本。借助分散仓库的优势，可以在不影响其他仓库的前提下对历史版本进行操作。

要让仓库的 HEAD、暂存区、当前工作树回溯到指定状态，需要用到 git rest –hard命令。只要提供目标时间点的哈希值，就可以完全恢复至该时间点的状态。事不宜迟，让我们执行下面的命令。

$ git reset --hard fd0cbf0d4a25f747230694d95cac1be72d33441d (使用时这里需要个人更改哈希值)
HEAD is now at fd0cbf0 Add index

git log命令只能查看以当前状态为终点的历史日志。所以这里要使用 git reflog命令，查看当前仓库的操作日志。在日志中找出回溯历史之前的哈希值，通过 git reset –hard命令恢复到回溯历史前的状态。

消除冲突

查看冲突部分并将其解决

用编辑器打开 README.md （如果你发生了冲突，查看相应的冲突文件）文件，就会发现其内容变成了下面这个样子。（这是书上的例子）

# Git教程
<<<<<<< HEAD
- feature-A
=======
- fix-B
>>>>>>> fix-B

======= 以上的部分是当前 HEAD 的内容，以下的部分是要合并的 fix-B 分支中的内容。我们在编辑器中将其改成想要的样子。

# Git教程
- feature-A
- fix-B

如上所示，本次修正让 feature-A 与 fix-B 的内容并存于文件之中。但是在实际的软件开发中，往往需要删除其中之一，所以各位在处理冲突时，务必要仔细分析冲突部分的内容后再行修改。

提交解决后的结果

冲突解决后，执行 git add命令与 git commit命令。

git commit –amend——修改提交信息

git rebase -i——压缩历史

在合并特性分支之前，如果发现已提交的内容中有些许拼写错误等，不妨提交一个修改，然后将这个修改包含到前一个提交之中，压缩成一个历史记录。这是个会经常用到的技巧，让我们来实际操作体会一下。

首先，新建一个 feature-C 特性分支。

作为 feature-C 的功能实现，我们在 README.md 文件中添加一行文字，并且故意留下拼写错误，以便之后修正。

$ git checkout -b feature-C
Switched to a new branch 'feature-C'

# Git教程
- feature-A
- fix-B
- faeture-C

提交这部分内容。这个小小的变更就没必要先执行 git add命令再执行 git commit命令了，我们用 git commit -am命令来一次完成这两步操作。

$ git commit -am "Add feature-C"
[feature-C 7a34294] Add feature-C
1 file changed, 1 insertion(+)

现在来修正刚才预留的拼写错误。然后进行提交。

$ git commit -am "Fix typo"
[feature-C 6fba227] Fix typo
1 file changed, 1 insertion(+), 1 deletion(-)

错字漏字等失误称作 typo，所以我们将提交信息记为 “Fix typo”。实际上，我们不希望在历史记录中看到这类提交，因为健全的历史记录并不需要它们。如果能在最初提交之前就发现并修正这些错误，也就不会出现这类提交了。

我们来更改历史。将 “ Fix typo”修正的内容与之前一次的提交合并，在历史记录中合并为一次完美的提交。为此，我们要用到git rebase命令。

$ git rebase -i HEAD~2

用上述方式执行 git rebase命令，可以选定当前分支中包含HEAD（最新提交）在内的两个最新历史记录为对象，并在编辑器中打开。

pick 7a34294 Add feature-C
pick 6fba227 Fix typo
# Rebase 2e7db6f..6fba227 onto 2e7db6f
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
# x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

我们将 6fba227 的 Fix typo 的历史记录压缩到 7a34294 的 Add feature-C里。按照下图所示，将 6fba227 左侧的 pick 部分删除，改写为 fixup。

pick 7a34294 Add feature-C
fixup 6fba227 Fix typo
[detached HEAD 51440c5] Add feature-C
1 file changed, 1 insertion(+)
Successfully rebased and updated refs/heads/feature-C.

这样一来， Fix typo 就从历史中被抹去，也就相当于 Add feature-C中从来没有出现过拼写错误。这算是一种良性的历史改写。

推送至远程仓库

git remote add——添加远程仓库

在 GitHub 上创建的仓库路径为“git@github.com:用户名 /git-tutorial.git”。现在我们用 git remote add命令将它设置成本地仓库的远程仓库。

$ git remote add origin git@github.com:github-book/git-tutorial.git

按照上述格式执行 git remote add命令之后， Git 会自动git@github.com:github-book/git-tutorial.git远程仓库的名称设置为 origin（标识符）。

git push——推送至远程仓库

推送至 master 分支

如果想将当前分支下本地仓库中的内容推送给远程仓库，需要用到git push命令。现在假定我们在 master 分支下进行操作。

$ git push -u origin master
Counting objects: 20, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (10/10), done.
Writing objects: 100% (20/20), 1.60 KiB, done.
Total 20 (delta 3), reused 0 (delta 0)
To git@github.com:github-book/git-tutorial.git
* [new branch] master -> master
Branch master set up to track remote branch master from origin.

像这样执行 git push命令，当前分支的内容就会被推送给远程仓库origin 的 master 分支。 -u参数可以在推送的同时，将 origin 仓库的 master 分支设置为本地仓库当前分支的 upstream（上游）。添加了这个参数，将来运行 git pull命令从远程仓库获取内容时，本地仓库的这个分支就可以直接从 origin 的 master 分支获取内容，省去了另外添加参数的麻烦。执行该操作后，当前本地仓库 master 分支的内容将会被推送到GitHub 的远程仓库中。在 GitHub 上也可以确认远程 master 分支的内容和本地 master 分支相同。

推送至 master 以外的分支

除了 master 分支之外，远程仓库也可以创建其他分支。举个例子，我们在本地仓库中创建 feature-D 分支，并将它以同名形式 push 至远程仓库。

$ git checkout -b feature-D
Switched to a new branch 'feature-D'

我们在本地仓库中创建了 feature-D 分支，现在将它 push 给远程仓库并保持分支名称不变。

$ git push -u origin feature-D
Total 0 (delta 0), reused 0 (delta 0)
To git@github.com:github-book/git-tutorial.git
* [new branch] feature-D -> feature-D
Branch feature-D set up to track remote branch feature-D from origin.

从远程仓库获取

git clone——获取远程仓库

获取远程仓库

首先我们换到其他目录下，将 GitHub 上的仓库 clone 到本地。注意不要与之前操作的仓库在同一目录下。

$ git clone git@github.com:github-book/git-tutorial.git
Cloning into 'git-tutorial'...
remote: Counting objects: 20, done.
remote: Compressing objects: 100% (7/7), done.
remote: Total 20 (delta 3), reused 20 (delta 3)
Receiving objects: 100% (20/20), done.
Resolving deltas: 100% (3/3), done.
$ cd git-tutorial

执行 git clone命令后我们会默认处于 master 分支下，同时系统会自动将 origin 设置成该远程仓库的标识符。也就是说，当前本地仓库的 master 分支与 GitHub 端远程仓库（origin）的 master 分支在内容上是完全相同的。

$ git branch -a
* master
remotes/origin/HEAD -> origin/master
remotes/origin/feature-D
remotes/origin/master

我们用 git branch -a命令查看当前分支的相关信息。添加 -a参数可以同时显示本地仓库和远程仓库的分支信息。结果中显示了 remotes/origin/feature-D，证明我们的远程仓库中已经有了 feature-D 分支。

获取远程的 feature-D 分支

我们试着将 feature-D 分支获取至本地仓库。

$ git checkout -b feature-D origin/feature-D
Branch feature-D set up to track remote branch feature-D from origin.
Switched to a new branch 'feature-D'

-b 参数的后面是本地仓库中新建分支的名称。为了便于理解，我们仍将其命名为 feature-D，让它与远程仓库的对应分支保持同名。新建分支名称后面是获取来源的分支名称。例子中指定了 origin/feature-D，就是说以名为 origin 的仓库（这里指 GitHub 端的仓库）的 feature-D 分支为来源，在本地仓库中创建 feature-D 分支。

git pull——获取最新的远程仓库分支

远程仓库的 feature-D 分支中已经有了我们刚刚推送的提交。这时我们就可以使用 git pull 命令，将本地的 feature-D 分支更新到最新状态。当前分支为 feature-D 分支。

$ git pull origin feature-D
remote: Counting objects: 5, done.
remote: Compressing objects: 100% (1/1), done.
remote: Total 3 (delta 1), reused 3 (delta 1)
Unpacking objects: 100% (3/3), done.
From github.com:github-book/git-tutorial
* branch feature-D -> FETCH_HEAD
First, rewinding head to replay your work on top of it...
Fast-forwarded feature-D to ed9721e686f8c588e55ec6b8071b669f411486b8.

如何用Github的gh-pages分支展示自己的项目

git subtree push --prefix=dist origin gh-pages

意思就是把指定的dist文件提交到gh-pages分支上

使用shell创建文本菜单和窗口部件

2017-11-29T00:00:00+00:00

来源： Linux命令行与shell脚本编程大全

内容：

创建文本菜单

创建文本窗口部件

添加X Window图形

创建文本菜单

创建交互式shell脚本最常用的方法是使用菜单，它提供了各种选项帮助脚本用户了解脚本能做到的和不能做的。

shell脚本菜单的核心是case命令，该命令会根据用户在菜单上的选择来执行特定命令。

下面我们逐步了解和创建基于菜单的shell脚本的步骤。

创建菜单布局

第一步是决定在菜单上显示哪些元素以及想要显示的布局方式。

在创建菜单前，通常先清空显示器上已有的内容。这样能在干净的，没有干扰的环境中显示菜单了。

clear命令使用当前终端的terminfo数据来清理出现在屏幕上的文字。运行clear命令后可以使用echo命令显示菜单元素。

默认，echo命令只显示可打印的文本字符。而在创建菜单时一些非文本字符也非常有用，比如制表符和换行符。我们需要添加-e选项使得echo命令能解析包含在其中的非文本字符。

例如，

wsx@wsx:~/tmp$ echo -e "1.\tDisplay disk space"
1.	Display disk space

这对于格式化菜单项布局非常方便，只需要几个echo命令就可以创建一个还不错的菜单。

clear
echo
echo -e "\t\t\tSys Admin Menu\n"
echo -e "\t1. Display disk space"
echo -e "\t2. Display logged on users"
echo -e "\t3. Display memory usage"
echo -e "\t0. Exit menu\n\n"
echo -en "\t\tEnter an option: "

最后一行-en选项去掉末尾换行符使得菜单更专业点，光标会在行尾等待用户输入。

创建菜单的最后一步是获取用户输入。这一步用read命令。因为我们只期望用户使用单字符输入，在命令加-n选项进行限定。这样用户只需要输入一个数字，不用摁回车键。

read -n 1 option

创建菜单函数

shell脚本菜单选项作为一组独立的函数实现起来更为容易。要做到这一点，你要为每个菜单项创建独立的shell函数。第一步是决定你希望脚本执行那些功能，然后将这些功能以函数的形式放在代码中。

通常我们会为还没有实现的函数先创建一个桩函数，它是一个控函数，或者只有一个echo语句，说明最终这里需要什么内容。

function diskspace {
  clear
  echo "This is where the diskspace commands will do"
}

这允许菜单在我实现某个函数时仍然能正常操作。不需要我们写出所有函数之后才能让菜单投入使用。函数从clear命令开始，这样我们就能在一个干净的屏幕上执行该函数，不会收到原先菜单的干扰。

另外，将菜单布局本身作为一个函数来创建有利于菜单制作。

function menu {
  	clear
	echo
	echo -e "\t\t\tSys Admin Menu\n"
	echo -e "\t1. Display disk space"
	echo -e "\t2. Display logged on users"
	echo -e "\t3. Display memory usage"
	echo -e "\t0. Exit menu\n\n"
	echo -en "\t\tEnter an option: "
	read -n 1 option
}

这样我们能在任何时候调用该函数以此重现菜单。

添加菜单逻辑

下一步我们需要创建程序逻辑将菜单布局和函数结合起来。这需要使用case命令。

case命令应该根据菜单中输入的字符来调用相应的函数，用case命令字符星号来处理所有不正确的菜单项。

下面展示了典型菜单的case用法：

menu
case $option in
0)
	break ;;
1) 
	diskspace ;;
2) 
	whoseon ;;
3) 
	memusage ;;
*)
	clear
	echo "Sorry, wrong selection";;
esac

这里首先调用menu函数清空屏幕并显示菜单。menu函数中的read命令会一直等待，知道用户在键盘上键入一个字符。然后case命令会接管余下的处理过程，基于字符调用相应的函数。

整合shell脚本菜单

现在让我们将前面的步骤全部组合起来，看看它们是如何协作的。

这是一个完整的菜单脚本例子：

wsx@wsx:~/tmp$ cat test14
#!/bin/bash
# simple script menu

function diskspace {
	clear
	df -k
}

function whoseon {
	clear
	who
}

function memusage {
	clear
	cat /proc/meminfo
}

function menu {
	clear
	echo
	echo -e "\t\t\tSys Admin Menu\n"
	echo -e "\t1. Display disk space"
	echo -e "\t2. Display logged on users"
	echo -e "\t3. Display memory usage"
	echo -e "\t0. Exit menu\n\n"
	echo -en "\t\tEnter an option: "
	read -n 1 option
}

while [ 1 ]
do
	menu
	case $option in
	0)
		break ;;
	1)
		diskspace ;;
	2)
		whoseon ;;
	3)
		memusage ;;
	*)
		clear
		echo "Sorry, wrong selection" ;;
	esac
	echo -en "\n\n\t\t\tHit any key to continue"
	read -n 1 line
done
clear

使用：

			Sys Admin Menu

	1. Display disk space
	2. Display logged on users
	3. Display memory usage
	0. Exit menu


		Enter an option: 

输入1：

文件系统           1K-块     已用      可用 已用% 挂载点
udev             4006080        0   4006080    0% /dev
tmpfs             807220    81004    726216   11% /run
/dev/sda4      305650672 14226064 275828680    5% /
tmpfs            4036100     1724   4034376    1% /dev/shm
tmpfs               5120        4      5116    1% /run/lock
tmpfs            4036100        0   4036100    0% /sys/fs/cgroup
/dev/sda3         524272     4684    519588    1% /boot/efi
tmpfs             807220       52    807168    1% /run/user/1000
tmpfs             807220       16    807204    1% /run/user/125
/dev/sda2      421886972 23340376 398546596    6% /media/wsx/存储


			Hit any key to continue

其他都可以自己测试一下，我就不赘言了。

使用select命令

select命令只需要一条命令就可以创建出菜单，然后获取输入的答案并自动处理。

命令格式如下：

select variable in list
do
	commands
done

list参数是由空格分隔的文本选项列表，这些列表构成了整个菜单。select命令会将每个列表项显示成一个带编号的选项，然后为选项显示一个由PS3环境变量定义的特殊提示符。

wsx@wsx:~/tmp$ cat smenu1 
#!/bin/bash
# using select in the menu

function diskspace {
	clear
	df -k
}

function whoseon {
	clear
	who
}

function memusage {
	clear
	cat /proc/meminfo
}

PS3="Enter an option: "
select option in "Display disk space" "Display logged on users" "Display memory usage" "Exit program"
do
	case $option in
	"Exit program")
		break ;;
	"Display disk space")
		diskspace ;;
	"Display logged on users")
		memusage ;;
	"Display memory usage"）
		memusage ;;
	*)
		clear
		echo "Sorry, wrong selection";;
	esac
done
clear

运行会自动生成如下菜单项：

wsx@wsx:~/tmp$ ./smenu1 
1) Display disk space	    3) Display memory usage
2) Display logged on users  4) Exit program
Enter an option:

在使用select命令时，记住存储在变量中的结果值是整个文本字符串而不是跟菜单项相关联的数字。文本字符串是要在case语句中比较的内容。

制作窗口

dialog包能够用ANSI转义控制字符在文本环境中创建标准的窗口对话框。我们可以将这些对话框融入自己的shell脚本中，借此与用户进行交互。这部分我们来学习如何使用dialog包。

安装：

sudo apt-get install dialog

dialog包

dialog包使用命令行参数来决定生成哪种窗口部件（widget）。部件是dialog包中窗口元素的术语。

部件	描述
calendar	提供选择日期的日历
checklist	显示多个选项（其中每个选项都能打开或关闭）
form	构建一个带有标签以及文本字段（可以填写内容）的表单
fselect	提供一个文件选择窗口来浏览选择文件
gauge	显示完成的百分比进度条
infobox	显示一条消息，但不用等待回应
inputbox	提供一个输入文本用的文本表单
inputmenu	提供一个可编辑的菜单
menu	显示可选择的一系列选项
msgbox	显示一条消息，并要求用户选择OK按钮
pause	显示一个进度条来显示暂定期间的状态
passwordbox	显示一个文本框，但会隐藏输入的文本
passwordform	显示一个带标签的隐藏文本字段的表单
radiolist	提供一组菜单选项，但只能选择其中一个
tailbox	用tail命令在滚动窗口中显示文件的内容
tailboxbg	跟tailbox一样，但是在后台模式中运行
textbox	在滚动窗口中显示文件的内容
timebox	提供一个选择小时、分钟和秒数的窗口
yesno	提供一条带有Yes和No按钮的简单消息

如上表所见，我们可以选择很多不同的部件。只需要多花点功夫就可以让脚本看起来更专业。

要在命令行上指定某个特定的部件，需要使用双破折线格式：

dialog --widget parameters

其中widget是上表中某个特定的部件，parameters定义了部件窗口的大小以及部件需要的文本。

每个dialog部件都提供了两种形式的输出：

使用STDERR
使用退出状态码

可以通过dialog命令的退出状态码来确定用户选择的按钮。如果选择了Yes或OK按钮，命令会返回状态码0。如果选择了Cancer或No按钮，命令会返回状态码1。可用标准的$?变量来确定dialog部件具体选择了哪个按钮。

如果部件返回了数据，dialog命令会将数据发送到STDERR。我们可以用标准的bash shell方法将其重定向到另一个文件或文件描述符中。

dialog --inputbox "Enter your age:" 10 20 2>age.txt

这条命令将文本框输入的文本重定向到age.txt文本中。

msgbox部件

msgbox部件是对话框中最常见的类型。它会在窗口中显示一条简单的信息，直到用户点击OK后消失。

使用格式：

dialog --msgbox text height width

text参数是要在窗口显示的字符串，height与width参数设定自动换行的窗口大小。如果想要在窗口加一个标题，可以使用--title参数，后接作为标题的文本。

例子：

dialog --title Testing --msgbox "This is a test" 10 20

输入命令后，消息框会显示在终端上。如果你的终端仿真器支持鼠标，可以单击OK来关闭对话框，也可以按下回车键。

yesno部件

该部件在窗口底部生成两个按钮：一个是Yes，一个是No。用户可以用鼠标、制表符或者键盘方向键来切换按钮。选择按钮则使用空格或者回车键。

下面是一个例子：

wsx@wsx:~$ dialog --title "Please answer" --yesno "Is this thing on?" 10 20
# 中间终端有输出
wsx@wsx:~$ echo $?
0

dialog命令的退出状态码会根据用户选择的按钮来设置。选择No返回1，选择Yes就是0。

inputbox部件

inputbox部件提供了一个简单的文本框区域来输入文本字符串，dialog会将它传到STDERR，我们需要重定向获得输入。inputbox提供了两个按钮：OK和Cancel。如果选择了OK，命令退出状态码为0，否则为1。

wsx@wsx:~/tmp$ dialog --inputbox "Enter your age:" 10 20 2>age.txt
wsx@wsx:~/tmp$ cat age.txt 
24

如果你自己运行过的话就会注意到该值后面没有换行符，这让我们能够轻松将文本内容重定向到脚本变量中，以获得用户输入的值。

textbox部件

textbox部件是在窗口中显示大量信息的极佳办法。它会生成一个滚动窗口来显示由参数所指定的文件中的文本。

wsx@wsx:~/tmp$ dialog --textbox /etc/passwd 15 45

/etc/passwd文件内容显示在可滚动的文本窗口中，可以用方向键来左右或上下滚动显示文件的内容。窗口底部的行会显示当前查看文本处于文件中的哪个位置（百分比）。文本框只包含一个用来选择退出部件的Exit按钮。

我们可以用这个部件来创建之前（上一篇笔记）中制作的文本菜单的窗口版本。只要为每个选项提供一个选择标号和文本就行。

wsx@wsx:~/tmp$ dialog --menu "Sys Admin Menu" 20 30 10 1 "Display disk space" 2 "Display users" 3 "Display memory usage" 4 "Exit" 2>test.txt

第一个参数定义了菜单的标题，之后的两个参数定义了菜单窗口的高和宽，而第四个参数则定义了在窗口中一次显示的菜单项总数。如果存在更多选择，则有滚动条。

菜单项必须使用菜单对：第一个元素是用来选择菜单项的标号（必须唯一）；第二个元素是菜单中使用的文本。

dialog命令会将选定（鼠标点击或回车键或选择OK）的菜单项文本发送到STDERR。

fselect部件

该部件在处理文件名时非常方便。不用强制用户键入文件名，我们就可以用fselect部件来浏览文件的位置并选择文件。

使用格式：

wsx@wsx:~/tmp$ dialog --title "Select a file" --fselect $HOME/ 10 50 2>file.txt

第一个参数是窗口使用的其实目录位置。fselect部件窗口由左侧的目录列表、右侧的文件列表和含有当前选定的文件或目录的简单文本框组成。可以手动在文本框键入文件名，或者用目录和文件列表来选定（使用空格键选定）。

dialog选项

除了标准部件，dialog还有大量定制的选项。前面我们使用的title就是一个。

下面显示了命令可用的选项：

选项	描述
–add-widget	继续下一个对话框直到按下Esc或Cancel选项
–aspect ratio	直到窗口宽度和高度的宽高比
–backtitle title	直到显示在屏幕顶部背景上的图标
–begin x y	指定窗口左上角的起始位置
–cancel-label label	指定Cancel按钮的替代标签
–clear	用默认的对话背景色来清空屏幕内容
–colors	在对话文本中嵌入ANSI色彩编码
–cr-wrap	在对话文本中允许使用换行符并强制换行
–create-rc file	将示例配置文件的内容复制到指定的file文件中
–defaultno	将yes/no对话框的默认答案设为no
–default-item string	设定复选列表、表单或菜单对话中的默认项
–exit-label label	指定Exit按钮的替代标签
–extra-button	在OK按钮和Cancel按钮之间显示一个额外按钮
–extra-label label	指定额外按钮的替换标签
–help	显示dialog命令的帮助信息
–help-button	在OK按钮和Cancel按钮后显示一个Help按钮
–help-label label	指定Help按钮的替换标签
–help-status	当选定Help按钮后，在帮助信息后写入多选列表、单选列表或表单信息
–ignore	忽略dialog不能识别的选项
–input-fd fd	指定STDIN之外的另一个文件描述符
–insecure	在passwd部件中键入内容时显示星号
–item-help	为多选列表、单选列表或菜单中的每个标号在屏幕底部添加一个帮助栏
–keep-window	不要清除屏幕上显示过的部件
–max-input size	指定输入的最大字符串长度。默认为2048
–nocancel	隐藏Cancel按钮
–no-collapse	不要将对话文本中的制表符转换为空格
–no-kill	将tailboxbg对话放到后台，并禁止该进程的SIGHUP信号
–no-label label	为No按钮指定替换标签
–no-shadow	不要显示对话窗口的阴影效果
–ok-label label	指定OK按钮的替换标签
–output-fd fd	指定除STDERR之外的另一个输出文件描述符
–print-maxsize	将对话窗口的最大尺寸打印到输出中
–print-size	将每个对话窗口的大小打印到输出中
–print-version	将dialog的版本号打印到输出中
–separate-output	一次一行地输出checklist部件的结果，不使用引号
–separator string	指定用于分隔部件输出的字符串
–separate-widget string	指定用于分隔部件输出的字符串
–shadow	在每个窗口右下角绘制阴影
–single-quoted	需要时对多选列表的输出采用单引号
–sleep sec	在处理完对话窗口后延迟指定的秒数
–stderr	将输出发送到STDERR（默认）
–stdout	将输出发送到STDOUT
–tab-correct	将制表符转换为空格
–tab-len n	指定一个制表符占用的空格数（默认为8）
–timeout sec	指定无用户输入时，sec秒后退出并返回错误代码
–title title	指定对话窗口的标题
–trim	从对话文本中删除前导空格和换行符
–visit-tiems	修改对话窗口制表符的停留位置，使其包括选项列表
–yes-label label	为Yes按钮指定替换标签

--backtitle选项是为脚本中的菜单创建公共标题的简便办法。上表提供的强大特性允许我们创建任何需要的窗口。

dialog命令支持运行时配置。该命令会根据配置文件模板创建一份配置文件。dialog启动时会先去检查是否设置了DIALOGRC环境变量，该变量会保存配置文件名信息。如果未设置该变量或未找到该文件，它会将$HOME/.dialogrc作为配置文件。如果这个文件还不存在的话就尝试查找编译时指定的GLOBALRC文件，也就是/etc/dialogrc。如果还不存在就用编译时的默认值。

在脚本中使用dialog命令

必须记住两件事：

如果有Cancel或No按钮，检查dialog命令的退出状态码
重定向STDERR来获得输出值

接下来是一个简单的实例，使用dialog部件生成我们之前（上一篇笔记）所创建的系统管理菜单。

wsx@wsx-laptop:~$ cat menu3
#!/bin/bash
# using dialog to create a menu

temp=$(mktemp -t test.XXXXXX)
temp2=$(mktemp -t test2.XXXXXX)

function diskspace {
        df -k > $temp
        dialog --textbox $temp 20 60
}

function whoseon {
        who > $temp
        dialog --textbox $temp 20 50
}

function menusage {
        cat /proc/meminfo > $temp
        dialog --textbox $temp 20 50
}

while [ 1 ]
do
dialog --menu "Sys Admin Menu" 20 30 10 1 "Display disk space" 2 "Display users" 3 "Display memory usage" 0 "Exit" 2> $temp2
if [ $? -eq 1 ]
then
  break
fi

selection=$(cat $temp2)

case $selection in
1)
        diskspace ;;
2)
        whoseon ;;
3)
        memusage ;;
0)
        break ;;
*)
        dialog --msgbox "Sorry, invalid selection" 10 30
esac
done
rm -f $temp 2> /dev/null
rm -f $temp 2> /dev/null

使用while循环加一个真值常量创建了一个无限循环来显示菜单对话。当执行完每个函数后，脚本会返回继续显示菜单。

脚本使用了mktemp命令创建两个临时文件来保存dialog命令的数据。

后面本来还有图形环境中（KDE、GNOME）使用的一些流行包介绍。以后等我使用ubuntu写笔记时再作学习和介绍吧。

创建和使用shell函数

2017-11-26T00:00:00+00:00

来源： Linux命令行与shell脚本编程大全

内容

基本的脚本函数

返回值

在函数中使用变量

数组变量和函数

函数递归

创建库

在命令行上使用函数

我们可以将shell脚本代码放进函数中封装起来，这样就能在脚本中的任何地方多次使用它了。

下面我们来逐步了解如何创建自己的shell脚本函数并在应用中使用它们。

基本的脚本函数

函数是一个脚本代码块，我们可以为其命名并在代码中任何位置重用。要在脚本中使用该代码块，只要使用所起的函数名就行了。

创建函数

有两种格式可以创建函数。第一种格式是使用关键字function，后跟分配给该代码块的函数名。

funtion name{
	commands
}

name属性定义了赋予函数的唯一名称，commands是构成函数的一条或多条bash shell命令。

第二种格式更接近其他编程语言中定义函数的方式：

name() {
  commands
}

使用函数

要使用函数，只需要像其他shell命令一样，在行中指定函数名就行了。

wsx@wsx:~/tmp$ cat test1
#!/bin/bash
# using a function in a script

function func1 {
    echo "This is an example of a function"
}

count=1
while [ $count -le 5 ]
do
  func1
  count=$[ $count + 1 ] 
done

echo "This is the end of the loop"
func1
echo "Now, this is the end of the script"

wsx@wsx:~/tmp$ ./test1
This is an example of a function
This is an example of a function
This is an example of a function
This is an example of a function
This is an example of a function
This is the end of the loop
This is an example of a function
Now, this is the end of the script

注意，定义函数名func1的后面一定要跟{有空格隔开，不然会报错。函数要先定义再使用，接触过编程的想必不陌生吧。

返回值

bash shell会把函数当做一个小型脚本，运行结束时会返回一个退出状态码，有3种不同的方法来为函数生成退出状态码。

默认退出状态码

默认函数的退出状态码是函数中最后一条命令返回的退出状态码。我们可以使用标准变量$?在函数执行结束后确定函数的状态码。

wsx@wsx:~/tmp$ cat test2
#!/bin/bash
# testing the exit status of a function

func1() {
	echo "trying to display a non-existent file"
	ls -l badfile
}

echo "testing the function"
func1
echo "The exit status is: $?"
wsx@wsx:~/tmp$ ./test2
testing the function
trying to display a non-existent file
ls: 无法访问'badfile': 没有那个文件或目录
The exit status is: 2

函数的退出状态码是2，说明函数的最后一条命令没有成功运行。但你无法知道函数中其他命令中是否成功运行，我们来看看下面一个例子。

wsx@wsx:~/tmp$ cat test3
#!/bin/bash
# testing the exit status of a function

func1(){
	ls -l badfile
	echo "This was a test of a bad command"
}

echo "testing the function:"
func1
echo "The exit status is: $?"
wsx@wsx:~/tmp$ ./test3
testing the function:
ls: 无法访问'badfile': 没有那个文件或目录
This was a test of a bad command
The exit status is: 0

这次函数的退出状态码是0，尽管其中有一条命令没有正常运行。可见使用函数的默认退出状态码是很危险的，幸运的是，我们有几种办法解决它。

使用return命令

return命令允许指定一个整数值来定义函数的退出状态码，从而提供了一种简单的途径来编码设定函数退出状态码。

wsx@wsx:~/tmp$ cat test4
#!/bin/bash
# using the return command in a function

function db1 {
	read -p "Enter a value: " value
	echo "doubling the value"
	return $[ $value * 2 ] 
}

db1
echo "The new value is $?"
wsx@wsx:~/tmp$ ./test4
Enter a value: 4
doubling the value
The new value is 8

当使用这种方法时要小心，记住下面两条技巧来避免问题：

函数一结束就取返回值
退出状态码必须是0~255

如果在用$?变量提取函数的返回值之前使用了其他命令，函数的返回值就会丢失。任何大于255的整数值都会产生一个错误值。

wsx@wsx:~/tmp$ ./test4
Enter a value: 200
doubling the value
The new value is 144

使用函数输出

如同可以将命令的输出保存到shell变量一样，我们也可以对函数的输出采用同样的处理办法。

result=`db1`

这个命令会将db1函数的输出赋值给$result变量。下面是脚本的一个实例：

wsx@wsx:~/tmp$ cat test4b
#!/bin/bash
# using the echo to return a value

function db1 {
	read -p "Enter a value: " value
	echo $[ $value * 2 ]
}

result=$(db1)
echo "The new value is $result"
wsx@wsx:~/tmp$ ./test4b
Enter a value: 200
The new value is 400

函数会用echo语句来显示计算的结果，该脚本会查看db1函数的输出，而不是查看退出状态码。

通过这种技术，我们还可以返回浮点值和字符串值，这使它成为一种获取函数返回值的强大方法。

在函数中使用变量

在函数中使用变量时，我们需要注意它们的定义方式以及处理方法。这是shell脚本常见错误的根源。

向函数传递参数

函数可以使用标准的参数环境变量来表示命令行上传给函数的参数。例如，函数名会在$0变量中定义，函数命令行上的任何参数都会通过$1、$2定义。也可以用特殊变量$#来判断给函数的参数数目。

指定函数时，必须将参数和函数放在同一行：

func1 $value1 10

然后函数可以用参数环境变量来获得参数值。下面是一个例子：

wsx@wsx:~/tmp$ cat test5
#!/bin/bash
# passing parameters to a function

function addem {
	if [ $# -eq 0 ] || [ $# -gt 2 ]
	then
		echo -1
	elif [ $# -eq 1 ]
	then
		echo $[ $1 + $1 ]
	else
		echo $[ $1 + $2 ]
	fi
}

echo -n "Adding 10 and 15: "
value=$(addem 10 15)
echo $value
echo -n "Let's try adding just one number: "
value=$(addem 10)
echo $value
echo -n "Now trying adding no numbers: "
value=$(addem)
echo $value
echo -n "Finally, try add three numbers: "
value=$(addem 10 15 20)
echo $value
wsx@wsx:~/tmp$ ./test5
Adding 10 and 15: 25
Let's try adding just one number: 20
Now trying adding no numbers: -1
Finally, try add three numbers: -1

addem函数首先会检查脚本传给它的参数数目。如果没有任何参数，或者参数多于两个，addem会返回-1。如果只有一个参数，addem会将参数与自身相加。如果有两个参数，addem会将它们相加。

由于函数使用特殊参数环境变量作为自己的参数值，因此它无法直接获取脚本在命令行中的参数值。下面是个失败的例子：

wsx@wsx:~/tmp$ cat badtest1 
#!/bin/bash
# trying to access script parameters inside a function

function badfunc1 {
	echo $[ $1 * $2 ]
}

if [ $# -eq 2 ]
then
	value=$(badfunc1)
	echo "The result is $value"
else
	echo "Usage: badtest1 a b"
fi

wsx@wsx:~/tmp$ ./badtest1 10 15
./badtest1: 行 5: *  : 语法错误: 需要操作数 (错误符号是 "*  ")
The result is 

尽管函数也使用了$1与$2变量，但它们与主脚本中的变量不同，要使用它们必须在调用函数时手动传入。

wsx@wsx:~/tmp$ cat test6
#!/bin/bash
# trying to access script parameters inside a function

function func1 {
	echo $[ $1 * $2 ]
}

if [ $# -eq 2 ]
then
	value=$(func1 $1 $2)
	echo "The result is $value"
else
	echo "Usage: badtest1 a b"
fi

wsx@wsx:~/tmp$ ./test6
Usage: badtest1 a b
wsx@wsx:~/tmp$ ./test6 10 15
The result is 150

在函数中处理变量

作用域是变量可见的区域。对脚本的其他部分而言，函数定义的变量是隐藏的。这些概念其实是编程语言中通用的，想必学过一些其他编程的朋友早已有所理解了。

函数使用两种类型的变量：

全局变量
局部变量

全局变量

全局变量是在shell脚本中任何地方都有效的变量，如果你在函数内定义了一个全局变量，也可以在脚本的主体部分读取它的值。

默认情况下，我们在脚本中定义的任何变量都是全局变量。

wsx@wsx:~/tmp$ cat test7
#!/bin/bash
# using a global variable to pass a value

function db1 {
	value=$[ $value * 2 ] 
}

read -p "Enter a value: " value
db1
echo "The new value is: $value"

wsx@wsx:~/tmp$ ./test7
Enter a value: 10
The new value is: 20

无论变量在函数内外定义，在脚本中引用该变量都有效。这样其实非常危险，尤其是如果你想在不同的shell脚本中使用函数的话。它要求你清清楚楚地知道函数中具体使用了哪些变量，包括那些用来计算非返回值的变量。下面是一个如何搞砸的例子：

wsx@wsx:~/tmp$ cat badtest2
#!/bin/bash
# demonstrating a bad use of variable

function func1 {
	temp=$[ $value + 5 ]
	result=$[ $temp * 2 ]
}

temp=4
value=6

func1
echo "The result is $result"
if [ $temp -gt $value ]
then
	echo "temp is larger"
else
	echo "temp is smaller"
fi
wsx@wsx:~/tmp$ ./badtest2
The result is 22
temp is larger

由于函数中用到了$temp变量，它的值在脚本中使用时受到了影响，产生了意想不到的后果。后面我们会学习如何处理这样的问题。

局部变量

无需在函数中使用全局变量，函数内部使用的任何变量都可以被声明成局部变量。我们只需要在变量声明前加上local关键字就可以了。

local temp

也可以在变量赋值时使用local关键字：

local temp=$[ $value + 5 ]

local关键字保证了变量只局限于该函数中。我们再回看刚才的例子：

wsx@wsx:~/tmp$ cat test8
#!/bin/bash
# demonstrating the local keyword

function func1 {
	local temp=$[ $value + 5 ]
	result=$[ $temp * 2 ]
}

temp=4
value=6

func1
echo "The result is $result"
if [ $temp -gt $value ]
then
	echo "temp is larger"
else
	echo "temp is smaller"
fi

wsx@wsx:~/tmp$ ./test8
The result is 22
temp is smaller

数组变量和函数

在函数中使用数组变量值有点麻烦，还需要一些特殊考虑。下面我们使用一种方法来解决问题。

向函数传数组参数

这个方法有点不好理解，将数组变量当做单个参数传递的话不起作用，下面我们看一个bad例子：

wsx@wsx:~/tmp$ cat badtest3
#!/bin/bash
# trying to pass an array variable

function testit {
	echo "The parameters are: $@"
	thisarray=$1
	echo "The received array is ${thisarray[*]}"
}

myarray=(1 2 3 4 5)
echo "The original array is: ${myarray[*]}"
testit $myarray
wsx@wsx:~/tmp$ ./badtest3
The original array is: 1 2 3 4 5
The parameters are: 1
The received array is 1

可以看到，当我们将数组变量当做函数参数传递时，函数只会取数组变量的第一个值。

针对这个问题，我们的一个解决方案是将数组变量全部拆分为单个值，然后作为参数传入函数，在函数内部又重新对这些值进行组装。

wsx@wsx:~/tmp$ cat test9
#!/bin/bash
# array variable to function test

function testit {
	local newarray
	newarray=(`echo "$@"`)
	echo "The new array value is: ${newarray[*]}"
}

myarray=(1 2 3 4 5)
echo ${myarray[*]}
testit ${myarray[*]}

wsx@wsx:~/tmp$ ./test9
1 2 3 4 5
The new array value is: 1 2 3 4 5

从函数中返回数组

采用与上面类似的方法，函数用echo语句来按正确顺序输出单个数组值，然后脚本再将它们重新放进一个新的数组变量中。

wsx@wsx:~/tmp$ cat test10
#!/bin/bash
# returning an array value

function arraydblr {
	local origarray
	local newarray
	local elements
	local i
	origarray=($(echo "$@"))
	newarray=($(echo "$@"))
	elements=$[ $# - 1 ]
	for (( i = 0; i <= $elements; i++ ))
	{
		newarray[$i]=$[ ${origarray[$i]} * 2]
	}
	echo ${newarray[*]}
}

myarray=(1 2 3 4 5)
echo "The orignal array is ${myarray[*]}"
arg1=$(echo ${myarray[*]})
result=($(arraydblr $arg1))
echo "The new array is: ${result[*]}"

wsx@wsx:~/tmp$ ./test10
The orignal array is 1 2 3 4 5
The new array is: 2 4 6 8 10

该脚本用$arg1变量将数组值传给arraydblr函数。该函数将数组重组到新的数组变量中，生成输出数组变量的一个副本，然后对数据元素进行遍历，将每个元素值翻倍，并将结果存入函数中该数组变量的副本。

函数递归

局部函数变量的一个特征是自成体系。这个特性使得函数可以递归地调用，也就是函数可以调用自己来得到结果。通常递归函数都有一个最终可以迭代到的基准值。

递归算法的经典例子是计算阶乘：一个数的阶乘是该数之前的所有数乘以该数的值。

比如5的阶乘：

5! = 1 * 2 * 3 * 4 * 5

方程可以简化为通用形式：

x! = x * (x-1)!

这可以用简单的递归脚本表达为：

function factorial {
  if [ $1 -eq 1 ]
  then
  	echo 1
  else
  	local temp=$[ $1 - 1 ]
  	local result=`factorial $temp`
  	echo $[ $result * $1 ]
  fi
}

下面用它来进行计算：

wsx@wsx:~/tmp$ cat test11
#!/bin/bash
# using recursion

function factorial {
	if [ $1 -eq 1 ]
	then
		echo 1
	else
		local temp=$[ $1 - 1]
		local result=`factorial $temp`
		echo $[ $result * $1 ]
	fi
}

read -p "Enter value: " value
result=$(factorial $value)
echo "The factorial of $value is: $result"

wsx@wsx:~/tmp$ ./test11
Enter value: 5
The factorial of 5 is: 120

创建库

如果你碰巧要在多个脚本中使用同一段代码呢？显然在每个脚本中都定义同样的函数太麻烦了，一种解决方法就是创建库文件，然后在脚本中引用它。

第一步是创建一个包含脚本中所需函数的公用库文件。下面是一个叫做myfuncs的库文件，定义了3个简单的函数。

wsx@wsx:~/tmp$ cat myfuncs
#!/bin/bash
# my script functions

function addem {
	echo $[ $1 + $2 ]
}

function multem {
	echo $[ $1 * $2 ]
}

function divem {
	if [ $2 -ne 0 ]
	then
		echo $[ $1 / $2 ]
	else
		echo -1
	fi
}

下一步是在用到这些函数的脚本文件中包含myfuncs库文件。

这里有点复杂，主要问题出在shell函数的作用域上。如果我们尝试像普通脚本一样运行库文件，函数不会出现在脚本中。

使用函数库的关键在于source命令。source命令会在当前shell上下文中执行命令，而不是创建一个新的shell。通过source命令就可以使用库中的函数了。

source命令有一个快捷别名，称为点操作符。要在shell脚本中运行myfuncs库文件，只需要使用下面这行：

. ./myfuncs

注意第一个点是点操作符，而第二个点指向当前目录（相对路径）。

下面这个例子假定myfuncs库文件与要使用它的脚本位于同一目录，不然需要使用相对应的路径进行访问。

wsx@wsx:~/tmp$ cat test12
#!/bin/bash
# using functions defined in a library file

. ./myfuncs

value1=10
value2=5
result1=$(addem $value1 $value2)
result2=$(multem $value1 $value2)
result3=$(divem $value1 $value2)
echo "The result of adding them is: $result1"
echo "The result of multiplying them is: $result2"
echo "The result of dividing them is: $result3"

运行：

wsx@wsx:~/tmp$ ./test12
The result of adding them is: 15
The result of multiplying them is: 50
The result of dividing them is: 2

在命令行上使用函数

有时候有必要在命令行界面的提示符下直接使用这些函数。这是个灰常不错的功能，在shell中定义的函数可以在整个系统中使用它，无需担心脚本是不是在PATH环境变量中。

重点在于让shell能够识别这些函数。以下有几种方法可以实现。

在命令行上创建函数

shell会解释用户输入的命令，所以可以在命令行上直接定义一个函数。

有两种方法。

一种是采用单行方式定义函数。

wsx@wsx:~/tmp$ function divem { echo $[ $1 / $2 ]; }
wsx@wsx:~/tmp$ divem 100 5
20

当在命令行上定义函数时，你必须记得在每个命令后面加个分号，这样shell能识别命令的起始。

另一种是采用多行方式来定义函数。在定义时bash shell会使用次提示符来提示输入更多命令。这种方法不必在命令末尾加分号，只要按回车键就可。

wsx@wsx:~/tmp$ function multem {
> echo $[ $1 * $2 ]
> }
wsx@wsx:~/tmp$ multem 2 5
10

注意：在命令行上创建函数不要跟内建命令重名，函数会覆盖原来的命令。

在.bashrc文件中定义函数

在bash shell每次启动时都会在主目录下查找.bashrc文件，不管是交互式shell还是shell中启动的新shell。所以我们可以将函数写入该文件，或者在脚本中写入命令读取函数文件。操作前面都讲过，不再赘述，只要把该文件当做脚本对待就可以了。理解这一点这部分就会了。

实例

在开源的世界里，共享代码才是关键，而这一点同样适用于脚本函数。我们可以下载大量各式各样的函数然后用于自己的应用程序。

这一节介绍如何下载、安装和使用GNU shtool shell脚本函数库。shtool库提供了一些简单的shell脚本函数，可以用来完成日常的shell功能。

下载和安装

shtool软件包下载地址：

http://mirrors.ustc.edu.cn/gnu/shtool/shtool-2.0.8.tar.gz # China

可以浏览器或者命令行下载：

wsx@wsx:~/tmp$ wget http://mirrors.ustc.edu.cn/gnu/shtool/shtool-2.0.8.tar.gz
--2017-11-24 00:34:32--  http://mirrors.ustc.edu.cn/gnu/shtool/shtool-2.0.8.tar.gz
正在解析主机 mirrors.ustc.edu.cn (mirrors.ustc.edu.cn)... 202.141.176.110, 218.104.71.170, 2001:da8:d800:95::110
正在连接 mirrors.ustc.edu.cn (mirrors.ustc.edu.cn)|202.141.176.110|:80... 已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度： 97033 (95K) [application/gzip]
正在保存至: “shtool-2.0.8.tar.gz”

shtool-2.0.8.tar.gz 100%[===================>]  94.76K  --.-KB/s    用时 0.1s  

2017-11-24 00:34:32 (783 KB/s) - 已保存 “shtool-2.0.8.tar.gz” [97033/97033])

复制到主目录，然后用tar命令提取文件：

wsx@wsx:~$ tar -zxvf shtool-2.0.8.tar.gz 
shtool-2.0.8/AUTHORS
shtool-2.0.8/COPYING
shtool-2.0.8/ChangeLog
shtool-2.0.8/INSTALL
shtool-2.0.8/Makefile.in
shtool-2.0.8/NEWS
shtool-2.0.8/RATIONAL
shtool-2.0.8/README
shtool-2.0.8/THANKS
shtool-2.0.8/VERSION
shtool-2.0.8/configure
shtool-2.0.8/configure.ac
shtool-2.0.8/sh.arx
shtool-2.0.8/sh.common
shtool-2.0.8/sh.echo
shtool-2.0.8/sh.fixperm
shtool-2.0.8/sh.install
shtool-2.0.8/sh.mdate
shtool-2.0.8/sh.mkdir
shtool-2.0.8/sh.mkln
shtool-2.0.8/sh.mkshadow
shtool-2.0.8/sh.move
shtool-2.0.8/sh.path
shtool-2.0.8/sh.platform
shtool-2.0.8/sh.prop
shtool-2.0.8/sh.rotate
shtool-2.0.8/sh.scpp
shtool-2.0.8/sh.slo
shtool-2.0.8/sh.subst
shtool-2.0.8/sh.table
shtool-2.0.8/sh.tarball
shtool-2.0.8/sh.version
shtool-2.0.8/shtool.m4
shtool-2.0.8/shtool.pod
shtool-2.0.8/shtool.spec
shtool-2.0.8/shtoolize.in
shtool-2.0.8/shtoolize.pod
shtool-2.0.8/test.db
shtool-2.0.8/test.sh

接下来可以构建shell脚本库文件了。

构建库

shtool文件必须针对特定的Linux环境进行配置。配置工作必须使用标准的configure和make命令：

wsx@wsx:~$ cd shtool-2.0.8/
wsx@wsx:~/shtool-2.0.8$ ./configure
Configuring GNU shtool (Portable Shell Tool), version 2.0.8 (18-Jul-2008)
Copyright (c) 1994-2008 Ralf S. Engelschall <rse@engelschall.com>
checking whether make sets $(MAKE)... yes
checking for perl interpreter... /usr/bin/perl
checking for pod2man conversion tool... /usr/bin/pod2man
configure: creating ./config.status
config.status: creating Makefile
config.status: creating shtoolize
config.status: executing adjustment commands
wsx@wsx:~/shtool-2.0.8$ make
building program shtool
./shtoolize -o shtool all
Use of assignment to $[ is deprecated at ./shtoolize line 60.
Generating shtool...(echo 11808/12742 bytes)...(mdate 3695/4690 bytes)...(table 1818/2753 bytes)...(prop 1109/2038 bytes)...(move 2685/3614 bytes)...(install 4567/5495 bytes)...(mkdir 2904/3821 bytes)...(mkln 4429/5361 bytes)...(mkshadow 3260/4193 bytes)...(fixperm 1471/2403 bytes)...(rotate 13425/14331 bytes)...(tarball 5297/6214 bytes)...(subst 5255/6180 bytes)...(platform 21739/22662 bytes)...(arx 2401/3312 bytes)...(slo 4139/5066 bytes)...(scpp 6295/7206 bytes)...(version 10234/11160 bytes)...(path 4041/4952 bytes)
building manpage shtoolize.1
building manpage shtool.1
building manpage shtool-echo.1
building manpage shtool-mdate.1
shtool-mdate.tmp around line 222: You forgot a '=back' before '=head1'
POD document had syntax errors at /usr/bin/pod2man line 71.
building manpage shtool-table.1
building manpage shtool-prop.1
building manpage shtool-move.1
building manpage shtool-install.1
building manpage shtool-mkdir.1
shtool-mkdir.tmp around line 186: You forgot a '=back' before '=head1'
POD document had syntax errors at /usr/bin/pod2man line 71.
building manpage shtool-mkln.1
building manpage shtool-mkshadow.1
shtool-mkshadow.tmp around line 191: You forgot a '=back' before '=head1'
POD document had syntax errors at /usr/bin/pod2man line 71.
building manpage shtool-fixperm.1
building manpage shtool-rotate.1
building manpage shtool-tarball.1
building manpage shtool-subst.1
building manpage shtool-platform.1
building manpage shtool-arx.1
building manpage shtool-slo.1
building manpage shtool-scpp.1
building manpage shtool-version.1
building manpage shtool-path.1

configure命令会检查构建shtool库文件所必需的软件。一旦发现所需工具，它会使用工具路径修改配置文件。

make命令负责构建shtool库文件。最终的结果（shtool）是一个完整的库软件包。

我们可以测试下这个库文件：

wsx@wsx:~/shtool-2.0.8$ make test
Running test suite:
echo..........FAILED
+---Test------------------------------
| test ".`../shtool echo foo bar quux`" = ".foo bar quux" || exit 1
| bytes=`../shtool echo -n foo | wc -c | awk '{ printf("%s", $1); }'` || exit 1
| test ".$bytes" = .3 || exit 1
| bytes=`../shtool echo '\1' | wc -c | awk '{ printf("%s", $1); }'` || exit 1
| test ".$bytes" = .3 || exit 1
| exit 0
+---Trace-----------------------------
| + ../shtool echo foo bar quux
| + test .foo bar quux = .foo bar quux
| + ../shtool echo -n foo
| + wc -c
| + awk { printf("%s", $1); }
| + bytes=3
| + test .3 = .3
| + ../shtool echo \1
| + wc -c
| + awk { printf("%s", $1); }
| + bytes=2
| + test .2 = .3
| + exit 1
+-------------------------------------
mdate.........ok
table.........ok
prop..........ok
move..........ok
install.......ok
mkdir.........ok
mkln..........ok
mkshadow......ok
fixperm.......ok
rotate........ok
tarball.......ok
subst.........ok
platform......ok
arx...........ok
slo...........ok
scpp..........ok
version.......ok
path..........ok
FAILED: passed: 18/19, failed: 1/19

（有一个没通过～）

如果全部通过测试，就可以将库安装到系统中，这样所有脚本都能使用这个库了。

要完成安装，需要使用make命令的install选项。需要使用root权限。

wsx@wsx:~/shtool-2.0.8$ make install
./shtool mkdir -f -p -m 755 /usr/local
./shtool mkdir -f -p -m 755 /usr/local/bin
./shtool mkdir -f -p -m 755 /usr/local/share/man/man1
mkdir: cannot create directory '/usr/local/share/man/man1': Permission denied
chmod: cannot access '/usr/local/share/man/man1': No such file or directory
Makefile:94: recipe for target 'install' failed
make: *** [install] Error 1
wsx@wsx:~/shtool-2.0.8$ sudo make install
[sudo] wsx 的密码： 
./shtool mkdir -f -p -m 755 /usr/local
./shtool mkdir -f -p -m 755 /usr/local/bin
./shtool mkdir -f -p -m 755 /usr/local/share/man/man1
./shtool mkdir -f -p -m 755 /usr/local/share/aclocal
./shtool mkdir -f -p -m 755 /usr/local/share/shtool
./shtool install -c -m 755 shtool /usr/local/bin/shtool
./shtool install -c -m 755 shtoolize /usr/local/bin/shtoolize
./shtool install -c -m 644 shtoolize.1 /usr/local/share/man/man1/shtoolize.1
./shtool install -c -m 644 shtool.1 /usr/local/share/man/man1/shtool.1
./shtool install -c -m 644 shtool-echo.1 /usr/local/share/man/man1/shtool-echo.1
./shtool install -c -m 644 shtool-mdate.1 /usr/local/share/man/man1/shtool-mdate.1
./shtool install -c -m 644 shtool-table.1 /usr/local/share/man/man1/shtool-table.1
./shtool install -c -m 644 shtool-prop.1 /usr/local/share/man/man1/shtool-prop.1
./shtool install -c -m 644 shtool-move.1 /usr/local/share/man/man1/shtool-move.1
./shtool install -c -m 644 shtool-install.1 /usr/local/share/man/man1/shtool-install.1
./shtool install -c -m 644 shtool-mkdir.1 /usr/local/share/man/man1/shtool-mkdir.1
./shtool install -c -m 644 shtool-mkln.1 /usr/local/share/man/man1/shtool-mkln.1
./shtool install -c -m 644 shtool-mkshadow.1 /usr/local/share/man/man1/shtool-mkshadow.1
./shtool install -c -m 644 shtool-fixperm.1 /usr/local/share/man/man1/shtool-fixperm.1
./shtool install -c -m 644 shtool-rotate.1 /usr/local/share/man/man1/shtool-rotate.1
./shtool install -c -m 644 shtool-tarball.1 /usr/local/share/man/man1/shtool-tarball.1
./shtool install -c -m 644 shtool-subst.1 /usr/local/share/man/man1/shtool-subst.1
./shtool install -c -m 644 shtool-platform.1 /usr/local/share/man/man1/shtool-platform.1
./shtool install -c -m 644 shtool-arx.1 /usr/local/share/man/man1/shtool-arx.1
./shtool install -c -m 644 shtool-slo.1 /usr/local/share/man/man1/shtool-slo.1
./shtool install -c -m 644 shtool-scpp.1 /usr/local/share/man/man1/shtool-scpp.1
./shtool install -c -m 644 shtool-version.1 /usr/local/share/man/man1/shtool-version.1
./shtool install -c -m 644 shtool-path.1 /usr/local/share/man/man1/shtool-path.1
./shtool install -c -m 644 shtool.m4 /usr/local/share/aclocal/shtool.m4
./shtool install -c -m 644 sh.common /usr/local/share/shtool/sh.common
./shtool install -c -m 644 sh.echo /usr/local/share/shtool/sh.echo
./shtool install -c -m 644 sh.mdate /usr/local/share/shtool/sh.mdate
./shtool install -c -m 644 sh.table /usr/local/share/shtool/sh.table
./shtool install -c -m 644 sh.prop /usr/local/share/shtool/sh.prop
./shtool install -c -m 644 sh.move /usr/local/share/shtool/sh.move
./shtool install -c -m 644 sh.install /usr/local/share/shtool/sh.install
./shtool install -c -m 644 sh.mkdir /usr/local/share/shtool/sh.mkdir
./shtool install -c -m 644 sh.mkln /usr/local/share/shtool/sh.mkln
./shtool install -c -m 644 sh.mkshadow /usr/local/share/shtool/sh.mkshadow
./shtool install -c -m 644 sh.fixperm /usr/local/share/shtool/sh.fixperm
./shtool install -c -m 644 sh.rotate /usr/local/share/shtool/sh.rotate
./shtool install -c -m 644 sh.tarball /usr/local/share/shtool/sh.tarball
./shtool install -c -m 644 sh.subst /usr/local/share/shtool/sh.subst
./shtool install -c -m 644 sh.platform /usr/local/share/shtool/sh.platform
./shtool install -c -m 644 sh.arx /usr/local/share/shtool/sh.arx
./shtool install -c -m 644 sh.slo /usr/local/share/shtool/sh.slo
./shtool install -c -m 644 sh.scpp /usr/local/share/shtool/sh.scpp
./shtool install -c -m 644 sh.version /usr/local/share/shtool/sh.version
./shtool install -c -m 644 sh.path /usr/local/share/shtool/sh.path

现在我们能在自己的shell脚本中使用这些函数咯。

shtool库函数

函数	描述
Arx	创建归档文件（包含一些扩展功能）
Echo	显示字符串，并提供了一些扩展构件
fixperm	改变目录树的文件权限
install	安装脚本或文件
mdate	显示文件或目录修改时间
mkdir	创建一个或更多目录
Mkln	使用相对路径创建链接
mkshadow	创建一棵阴影树
move	带有替换功能的文件移动
Path	处理程序路径
platform	显示平台标识
Prop	显示一个带有动画效果的进度条
rotate	转置日志文件
Scpp	共享的C预处理器
Slo	根据库的类别，分离链接器选项
Subst	使用sed的替换操作
Table	以表格的形式显示由字段分隔的数据
tarball	从文件和目录中创建tar文件
version	创建版本信息文件

每个shtool函数都包含大量的选项和参数。下面是使用格式：

shtool [option] [function [option] [args]]

使用库

我们能直接在命令行或者在自己构建的脚本中使用shtool的函数。

下面是在脚本中使用的简单例子：

wsx@wsx:~/tmp$ cat test13
#!/bin/bash
shtool platform
wsx@wsx:~/tmp$ ./test13
Ubuntu 17.10 (AMD64)

platform函数会返回Linux发行版以及系统使用的CPU硬件相关信息。

prop函数可以使用\,|,/和-字符创建一个旋转的进度条。它可以告诉shell脚本用户目前正在处理一些后台处理工作。

wsx@wsx:~/tmp$ ls -al /usr/bin | shtool prop -p "waiting..."
waiting...

在脚本学习中涉及到诸多的符号，在运行时我们可能会感觉到顺利，但自己写的时候往往会用不太对，推荐阅读一下常用的一些符号区分，像小括号、中括号、花括号等等。觉的不懂的可以看看Linux_Bash脚本_单引号’双引号“”反引号`小括号()中括号[]大括号{}以及相关的百度资料。

Bioconductor分析RNA-seq数据

2017-10-27T00:00:00+00:00

参考学习《R语言与Bioconductor生物信息学应用》第六章

前言

Y叔的公众号biobabble发过一篇【听说你想学R？】,七月份发的但昨天推送了一次，所以我看到了，看到了对《R语言与Bioconductor生物信息学应用》这本书的强力吐槽，而我发的这篇笔记，连同上次发的Bioconductor分析基因芯片数据都是来自于对该书内容的提炼和学习。所以呢我觉得有必要在这里说几句。

坦白说，这本书确实有很多问题，我自己讲讲几点吧：首先，它有点过时了，公众号评论就有人说基因芯片分析过时了，我个人觉得不客观，但确实这本书有些过时，由此产生了一系列问题，特别要提到的就是代码的可重复性，我个人在运行书中一些代码时很多时候会不work，然后我会自己思考怎么让它work，实在不行就放弃；第二点，它不适合R入门的人，特别是你去看它的第一章，云里雾里，好歹我也摸了半年R了啊，好吧，我就直接跳过了；第三点，它的流程不完整，就是不是很连续的都能让你从头到尾的go through下去，自然心里会感觉不爽快。如此种种。

接着你心里已经有准备听我下面要将的“but”的跳转了，我为什么会学它并做笔记，乃至分享出来？首先，在我需要学习芯片和RNAseq分析的时候身边刚好有这本书，我也不知道是谁的，好吧，那就拿起来看看，发现正是我需要的，所以我看它，第一章看不太懂，没意思，我也不想看，直接跳过从第二章看起，到现在整本书基本看了大半，看过的代码都尝试着去运行过，确实有所收获，所以我会写前言，算是对这本书的客观评价吧；其次，我想谈谈有哪些收获，我本人可以算是有编程基础的，算不得菜鸟，但是对于基因芯片的基础也好，RNAseq乃至基因组分析流程、背景等等可以说是菜鸟的不能再菜鸟，这本书给了我对芯片数据来源、处理流程的一些基本认知，其实这在一些国内资源上是找不到的。有一点我心里非常的不服气，为什么我听说中国做生信非常厉害的人很多，找得到的中文资料却很少？为什么百度其他搜索引擎很强大，一涉及科研领域就非常之垃圾？这也是我挺佩服生信技能树或类似的这样的团队以及相关个人，当我们在喷一些书籍很垃圾，而实际它确实有很多问题的时候，我们能不能贡献自己的力量呢？几个月的学习里我深知自己才能有限，所知甚少，所以不断模仿和记录。我把这些笔记陈列出来并不是它写的有多好，多值得模仿，而是它能够给予我们新的知识，又能够在我们忘记时方便查询。学习必然是一个探寻和思索的过程，技能的掌握它不是一本书可以带给你的，特别是一本技术类书籍，它给了你一个看似可行的方案，你要实际去操作它，然后心里给予评价，在你不确定时，需要多方面整理实践不同的解决方案，然后找到自己的出路，建立自己对该某个问题处理的完整体系。

这篇笔记并不会带你真正学好RNA-seq的分析，至少我看完之后没有，但它确实可以补一些知识的模块。它不适应入门R，也不适应完全模仿做具体的分析，而是适合你在掌握R之后，你在做测序分析之前想了解的一些知识。当你知道它非你所需，你可以完全不看它。

整体而言，这本书非常短，整体评价偏差，但国内在这个方面学习恐怕没有比这好的中文书籍吧？（所以我建议多看网络资料，这也是我在交互学习的，比如生信媛公众号文章目录）我希望那些厉害的人物（教授级人物们）能够多拓展一些中文科研的视界（提升国内人员对生信的整体认知与分析能力，加速学习周期），我也会持续记录这样一些知识，与生信技能树里面的小伙伴一起从不同的研究方向，角度去拓展形形色色的基础知识与理论。我再次强调，我专注于笔记的目的除了自身学习以外，是当你在面对一些概念或者问题的疑惑时，你能键入百度搜索后快速地链接到本文，并从中找到可执行的方案或者帮助你理解，而不是完完全全整篇的通读。而当你确实是需要对所有的知识点有学习的需求时，你再选择读它，不仅仅是这一篇笔记或博文。不要浪费自己的时间，也要耐心地投入自己的时间。

如果想了解测序基本原理和知识，查看我整理的测序与平台的几个链接。

使用的学习数据：NCBI SRA (Sequence Read Archive)数据库，数据集编号SRA091277

使用的是菊花转录组样品，分析过程包括原始数据获取、数据清理、质量控制、转录组拼接、转录本定量、标准化和表达差异分析等过程。

样品名称	样品描述	RUN编号	测序长度
T1	处理组（脱水处理3小时）	SRR921340	100bp
T2	处理组（脱水处理3小时）	SRR921341	100bp
T3	处理组（脱水处理3小时）	SRR921342	100bp
T1-1	处理组（脱水处理3小时）	SRR921346	51bp
T2-1	处理组（脱水处理3小时）	SRR921344	51bp
T3-1	处理组（脱水处理3小时）	SRR921345	51bp
CK1	对照组（不做任何处理）	SRR921321	100bp
CK2	对照组（不做任何处理）	SRR921322	100bp
CK3	对照组（不做任何处理）	SRR921324	100bp
CK1-1	对照组（不做任何处理）	SRR921336	51bp
CK2-1	对照组（不做任何处理）	SRR921337	51bp
CK3-1	对照组（不做任何处理）	SRR921338	51bp

高通量测序基础知识

（这里只记录书中重要的知识点并加以理解）

基于第二代测序建立起来的基因组测序、RNA-seq和Small RNA-seq等应用，都由样本收集、文库制备和测序三个过程组成，不同之处在于样品收集和文库制备。

第二代测序仪（Illumina）测的序列，无论来自DNA-seq文库还是RNA-seq文库，从左到右依次分为3个区域：5’接头（Adapter）区、目标序列区和3’接头区。当多个样品在一个泳道（Lane）中同时测序时，我们可以使用多样品（Multiplex）技术，具体而言是给每个样品分配一个不重复的条形码（Barcode），其实质是一个6-8位的DNA序列，测序后可以通过这个序列将不同的样品分开。单端测序（Single end）指仅从正向测序；双端测序（Paired end）指先从正向测序，然后从反向测序。Barcode则根据另一引物“Sb”独立测序得到。

理论上，由于制备的RNA-seq文库插入长度的峰值常常为200或300bp，所以测序应该只得到文库中目标序列5’端开始的部分（这就是常说的read了，以前总搞不懂~）。但是呢，文库中会有少量目标序列不到测序长度（比如测100bp实际目标序列只有几十），那么测序就可能会测到3’端接头序列，这就是所谓的接头污染。数据预处理时，如果发现接头序列过多，一般是RNA-seq文库插入长度没有控制好；如果出现大量全长的3’接头，一般是接头过量，导致了大量接头自连（Self ligation）。

实际应用中，估计测序深度使用更多的是达到质量标准的有效数据量，而不是原始数据量。当RNA-seq有效数据比例过低时，无法检测一些低丰度的转录本，要考虑重新测序。

测序深度，也叫乘数，指每个碱基被测序的平均次数，是用来衡量测序量的首要参数。测序覆盖度，也叫覆盖率，指被测序到的碱基占全基因组大小的比率。假如用Illumina 2000测序仪完成一次人类基因组（3G大小）单端测序，即可得到300G数据（假设全部是有效数据），估计的测序深度即为100倍（300G/3G），常见表示为100X。将所有读段比对到人类基因组，如果发现只有2.7G的碱基至少有1个读段覆盖到，其实际测序深度为111X（300G/2.7G），测序覆盖度为90%（2.7G/3G）。

不同的测序目的要使用不同的测序策略。如DNA组装使用较多的是2X100bp或更长的双端测序；RNA-seq使用较多的是100bp或更长的单端链特异性测序；small RNA-seq多用50bp单端测序。

从测序得到的读段组装成目标基因组或者转录组的基因策略是比对和拼接，比对是把读段定位到参考基因组或者转录组上，然后再拼接成连续序列；拼接也胶从头组装（Denovo assembly），是在没有参考基因组或者转录组前提下，根据读段之间的重叠区，把所有读段拼接起来，直接获得基因组或者转录组（参考文章）。

转录组比对常用的软件有BWA、Bowtie和Tophat；拼接常用的软件是Trinity。

基因组和转录组组装的不同点：基因组组装希望尽量获得唯一或较少的组装结果，即一致性序列（Consensus sequence）。一致性序列上并不是每个位点都只有一种碱基，它实际上只代表该位点出现频率最高的碱基，存在两种以上碱基的位点叫做杂合位点。注意，过分追求一致性会导致过拼接，即来自不同基因的相似序列会被误拼接到一起。基因组和转录组组装可以用一个非常重要的指标N50来评价，即将所有组装后的序列按照长度从大到小排列，累加值接近所有序列长度总和一半时的那个位置对应的序列长度。N50越大，组装的结果越好，类似的有N90。

测序的质量分数

Phred分数

测序中常用错误概率$P_e$（Error probability）来表示每个核苷酸测量的准确性，还可以赋予一个数值来更简便地表示这个意思，叫做测序质量分数（Quality score）。因为这个分数最开始通过Phred软件从测序仪生成的色谱图中得到的，所以也叫做Phred分数（$Q_{Phred}$）。Phred分数的取值范围是0到93，可以表示很宽的误差范围，即从1（完全错误）到非常低的错误率$10^{-93}$。Phred分数是最基本的质量分数，其他的质量计分标准都来自Phred分数。

$Q_{Phred} = -10\times log_{10}P_e$

$Q_{Phred}$	$P_{e}$	Base call accuracy
0	1	0
10	0.1	0.9
20	0.01	0.99
30	0.001	0.999
40	0.0001	0.9999
50	0.00001	0.99999

Sanger分数（Phred+33）

Phred分数包括2位数字，还需要用空格分隔，不方便阅读，又要占用大量存储空间，实际上文件中不采用它。为了在文件中方便地表示质量，常常将Phred分数加上33（从33到126变化，ASCII码正好覆盖了可打印区），并用其ASCII码值对应的字符表示，这就是Sanger分数。Sanger分数常用于FASTQ格式的文件。

Illumina/Solexa分数（Phred+64）

分数之间的转换公式：

$Q_{Solexa} = -10 \times log_{10}(\frac{P_e}{1-P_e}) \\ Q_{Solexa} = 10 \times log_{10}(10^{\frac{Q_{Phred}}{10}}- 1) \\ Q_{Phred} = 10 \times log_{10}(10^{\frac{Q_{Solexa}}{10}}- 1) \\$

Solexa分数的取值范围是-5到62，它在FASTQ文件中需要加上64并转换为相应的ASCII码值（59到126）对应的字符来表示质量。2006年，Illumina公司收购Solexa公司后继续沿用其标准。显著Illmina采用新的标准，采用了Phred分数（范围0-62）加64的质量分数。

Sanger分数（Phred+33）和Illumina分数（Phred+64）是当前应用最为普遍的质量分数系统。

以Phred=20（即常见的Q20标准）为例，其Sanger分数为53，对应数字5；其Illumina分数为84，对应字母T。

Bioconductor中的ShortRead包提供了SolexaQuality和PhredQuality函数分别生成Illumina分数和Sanger分数。

source("http://Bioconductor.org/biocLite.R")
biocLite("ShortRead")
library(ShortRead)
Q=20
PhredQuality(as.integer(Q))
SolexaQuality(as.integer(Q))

> Q=20
> PhredQuality(as.integer(Q))
  A PhredQuality instance of length 1
    width seq
[1]     1 5
> SolexaQuality(as.integer(Q))
  A SolexaQuality instance of length 1
    width seq
[1]     1 T

高通量测序文件格式

FASTQ格式

FASTQ格式是序列文件中常见的一种，它一般包括四部分：第一部分是由“@”开始，后面跟着序列的描述信息（对于高通量数据，这里是读段的名称），这点跟FASTA格式是一样的（起头的符号不一样）；第二部分是DNA序列；第三部分是由“+”号开始，后面或者是读段的名称，或者为空；第四部分是DNA序列上每个碱基的质量分数，每个质量分数对应一个DNA碱基。

Bioconductor中的ShortRead包提供了quality函数可以自动识别FASTQ文件中的质量分数的种类。

我随便写了一个fastq的demo文件，内容

@HWUSI-EAS100R:123:COEPYACXX:6:73:941:1973#0/1
GATTTGGGGTTCAAAGCAGTATCGATCAAAATAGTAAAATCCATTTGTTCAACTCACAGTTT
+ HWUSI-EAS100R:123:***********************
!"************************************************************

进行一些操作：

library(ShortRead)
# 读入FASTQ文件
reads <- readFastq("./demo.fastq")
# 得到质量分数的类型
score_sys <- data.class(quality(reads))
# 得到质量分数
qual <- quality(quality(reads)) # 这里好像一个quality函数就够了，还是尊重原文吧
# 质量分数转为16进制表示
myqual_mat <- charToRaw(as.character(unlist(qual)))

# 如果是Phred+64分数表示系统
if(score_sys=="SFastqQuality"){
  # 显示分数系统类型
  cat("The quality score system is Phred+64", "\n")
  # 输出原始分数值
  strtoi(myqual_mat, 16L)-64
}
# 如果是Phred+33分数表示系统
if(score_sys=="FastqQuality"){
  # 显示分数系统类型
  cat("The quality score system is Phred+33", "\n")
  # 输出原始分数值
  strtoi(myqual_mat, 16L)-33
}

The quality score system is Phred+33 
 [1] 0 1 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

NCBI中的FASTQ与SRA格式

NCBI的Sequence Read Archive （SRA）数据库，接受FASTQ格式的高通量数据上传，并将分数标准从开始的Illumina分数转换成了Sanger分数。而且，NCBI在读段名称前面增加了数据在SRA库的编号和版本，后面增加了读段的长度。SRA数据库为了节省存储空间，将FASTQ文件压缩为二进制的SRA格式进行保存。用户如果下载SRA格式数据，可以使用工具软件fastq-dump将数据从SRA格式转回FASTQ格式。

QUAL格式文件

Solid测序仪产生分离的序列文件（CSFASTA格式）和质量文件（QUAL格式），两者必须成对出现。QUAL文件采用Phred分数，而且行必须与FASTA文件中的行一一对应。CSFASTA文件与FASTA格式看似相同，但实际不同，Solid不是用核苷酸残基表示序列数据，而是采用了颜色空间的表示方法。Solid的序列文件如果和质量文件合并，可以产生CSFASTAQ格式的文件，也可以根据颜色编码转为真正的FASTAQ格式的文件。

Solid的结果文件转为标准FASTQ格式的文件需要注意两个问题：第一是第1个碱基由于来自测序引物，必须删除；第二就是由于Solid颜色空间的编码是前后依赖的，一旦错一个，会导致后面连续错误，一般都将参考基因组反转为颜色空间编码再进行比对等分析，而不主张将Solid的结果文件直接转换为FASTQ文件。

关于常见的生信数据文件格式，参见生信常见数据格式。

RNA-seq技术的特点

RNA-seq对芯片的优势

RNA-seq检测基因表达主要在7个方面比基因芯片有优势。

	基因芯片	RNA-seq
参考序列	需要	不需要
动态范围	小	大
背景噪声	大	小
受降解影响	大	小
序列变异	无法检测	可以检测
转录组方向	不能确定	能确定
可重复性	一般	高

RNA-seq存在的问题

RNA-seq测序之前需要一个比较复杂的文库构建过程，这个过程的每一步都可能带来误差甚至导致实验失败。如cDNA片段化、PCR扩增等都会带来偏倚，最终导致有的片段被反复测了多次，有的没有测到。rRNA去除不干净等因素也会带来大量污染（即非目标序列）。还有其他一些实验问题。
RNA-seq检测灵敏度和最大值是随测序深度变化的，深度不够，不能发现超低表达的转录本，需要在测序前预估转录本大小。而由于复杂的RNA编辑等原因，高等生物的转录组与其编码基因数量没有固定比例关系，所以预估容易产生较大误差。
参考基因组或转录组不准确、测序误差、错误拼接或比对带来的错误会大大影响各种变异或者可变剪切事件的识别。
各种其他的问题。比如整个实验流程可能引进了各种污染；原始数据预处理的数据模型不完善等等。

下面看一下如何计算由测序误差引起的Barcode的错误分配，假设Barcode（Barcode唯一确定样本）长度为6个碱基，每个Barcode两两之间两个碱基不同，所有的Barcode都用满，同时假设错误的发生符合二项分布，那么只要2个碱基错误，就会发生一次错误分配，在Illumina测序仪每个碱基的平均错误率0.5%的前提下，下面例子可以计算出一个泳道的错误错误分配概率。

> p = 0.0005
> sum(sapply(2:6, FUN=function(k) choose(6,k)*p^k*(1-p)^(6-k)))
[1] 3.745003e-06

也就是说，在一个泳道，每百万读段就会有370个读段分配错误。如果还考虑DNA簇混合和跳跃PCR引起的Barcode错误分配，这个数值还要高很多。这种分配错误对一般的转录组分析没有影响，但是对一些高灵敏度的突变检测项目影响很大。

Illumine 2000测序仪中，一次运行（Run）可以使用2个流动槽（Flow cell），每个流动槽包括8个泳道（Lane），一个泳道包含2个面（Surface），每个面还有3个条（Swath）也叫列（Column），每一列由16个小区（Tile）组成，后者又由大量DNA簇（Cluster）组成。

Illumine 2000测序仪每次运行（单端测序）理论上可以产生大约30亿个DNA簇，每个DNA簇理论上可以产生一条读段（Read），如果测序长度为100bp，一次运行可以得到3G个读段，其原始数据量为300G个碱基。

RNA-seq数据预处理

RNA-seq数据预处理与基因芯片预处理的目的一致，都是要得到基因表达数据，这里确切说是转录本。但它们的实现细节和方法则有很大不同，下面逐一介绍。

质量控制

数据质量分析报告可以调用ShortRead包中的qa函数得到，另一个常用的工具是FastQC。

下面是一个用qa函数生成质量分析报告的实例，示例数据来自SRA数据库的RNA-seq数据SRR921344。

library(BiocInstaller)
# 安装包
biocLite("SRAdb")
biocLite("R.utils")
# 导入包
library(ShortRead)
library(SRAdb)
library(R.utils)
# download data
db_dir <- "~/Projects/coGECP-pro/db/"
sra_dbname <- paste0(db_dir, 'SRAmetadb.sqlite')	
sra_con <- dbConnect( dbDriver("SQLite"), sra_dbname )
getFASTQfile("SRR921344", sra_con, destDir = "~/Projects/coGECP-pro/fast-format/", srcType = 'ftp', ascpCMD = NULL )
dbDisconnect( sra_con )

# 解压后改名
gunzip("../fast-format/SRR921344.fastq.gz", destname="../fast-format/T2-1.fastq")

# 需要分析的数据文件名称
fastqfile="T2-1.fastq"
# 得到质量分析的记过
qa <- qa(dirPath = "../fast-format/", pattern=fastqfile, type="fastq")

# 输出html格式的分析报告
report(qa, dest="qcReport", type="html")

执行完毕后会得到名为qcReport的结果目录，主要包括质量分析的报告文件“index.html”和文件夹“image”，image文件夹下包括所有的统计信息图示。

比较重要的图示信息有前20个高频出现的读段统计信息，这对于确定接头或者其他污染很重要。FastQC软件带有一个文件包括了常用的Illumina接头序列，会把高频出现的序列比对到这些接头序列，并给予提示；Biocondutor则需要编程比对到NCBI UniVec数据库（http://www.ncbi.nlm.nih.gov/tools/vecscreen/univec）来确定接头序列。

接下来是四种碱基的逐点质量图，该图横坐标是测序的循环数，对应测序时5’端开始的每个位点，纵坐标是所有该位点测量的碱基的质量分数平均数。

质量控制中最重要的一个图是逐点质量图，它与四种碱基逐点质量图的区别在于不区分碱基种类，给出每个位点的测序质量分数的平均数、中位数和上下四分位线。

通过质量控制，可以确定当前样品的数据是否应该保留进入下一步分析或者丢弃。对于通过质量控制的数据，还要进行读段处理，清理后的数据才是实际分析中使用的数据。

读段清理

读段清理主要去掉读段中多个“N”碱基，读段两端的低质量区域（质量分数少于Q20），读段3’端可能混入的接头序列，还有可能污染进来的rRNA和病毒序列。

转录组组装

转录组组装包括从头组装和基于参考序列的组装。从头组装最常用的软件是Trinity，其优点是：不依赖参考序列；能较好地重建变异的、可变剪切的或者来自染色体重组的转录本。从头组装的缺点是会消耗大量的内存资源，测序深度的需求也很高，对测序错误很敏感，高相似度的转录本可能会被误拼到一起。基于参考序列的组装常使用TopHat和Cufflinks（主要用于转录本的识别、定量、标准化与差异分析）两种软件的组合来完成。其优点是：内存需求小；污染影响小，因为污染读段不能比对到参考序列；灵敏度高，所需测序深度低，能检测低丰度的转录本；组装的转录本序列更完整；可以增加参考基因组中的转录本注释。基于参考序列的组装的缺点：严重依赖参考序列及其注释信息等。

转录组定量和标准化

有参的转录组定量，需要利用TopHat比对软件将所有读段比对到参考基因组上，然后由Cuffinks软件完成定量；无参的转录组定量需要利用Bowtie或BWA比对软件将所有读段比对到组装得到的转录组上直接计数。

单端测序读段的比对比较简单，双端测序的质量不一致，往往是反向一端测序质量低，如果按照同样的标准要求两端测序的读段都比对上，会丢失很多比对结果。一般采取的方式是两端读段分别依据不同的标准（例如正向允许错配一个，反向允许错配两个）做单端比对，然后根据两端对齐后中间距离抽取成对的比对结果。

转录组定量得到的基因表达矩阵是简单计数得来的，因此称作原始计数（Raw counts）。有参的转录组定量，可以用Bioconductor的GenomicRanges/Rsamtools软件包中的summarizeOverlaps函数实现。输入的数据为比对后得到的Bam或者Sam文件，经过基因水平或者外显子水平的计数，可以直接输出为某种预定义对象，便于下游软件（如edgeR包和DESeq包）继续处理。

下面例子使用summarizeOverlaps函数从Bam文件中获取原始计数，并输出为edgeR包和DESeq包中的数据对象。

require(BiocInstaller)
# biocLite("TxDb.Dmelanogaster.UCSC.dm3.ensGene")
# biocLite("DESeq")
require(Rsamtools)
require(DESeq)
require(edgeR)
require(pasillaBamSubset)
library(GenomicAlignments)

#此处数据已经不能用了，所以从其他包里弄了个bam格式文件试试
# bamfile <- system.file("extdata", "ex1.bam", package="Rsamtools")
# bf1 <- BamFileList(bamfile, index=character())
# features <- GRanges(seqnames = c())

# from GenomicRanges::GenomicRangesHOWTOs	
reads <- c(untrt1=untreated1_chr4(),
             untrt3=untreated3_chr4())
# single-end reads
# paired-end reads

library(TxDb.Dmelanogaster.UCSC.dm3.ensGene)
exbygene <- exonsBy(TxDb.Dmelanogaster.UCSC.dm3.ensGene, "gene")
se <- summarizeOverlaps(exbygene, reads, mode="IntersectionNotEmpty")

# back 
deseq <- newCountDataSet(assays(se)$counts, rownames(colData(se)))
edger <- DGEList(assays(se)$counts, group=rownames(colData(se)))

类似基因芯片，RNA-seq定量后的数据需要标准化，使得所有的样品具有可比性。最常见的一个指标是RPKM（Reads Per Kilo base per Million reads），即每百万读段中来自某一个基因每千碱基长度的读段数目。具体计算时使用比对到某个基因的读段个数除以比对到基因组或者转录组的所有读段个数（以百万为单位），再除以基因或转录本的长度（以KB为单位）。基因表达差异分析的常用软件edgeR软件和DESeq都自带了数据标准化功能，可以直接处理用原始计数表示的基因表达矩阵，RPKM表示的基因表达矩阵的使用主要是为了方便用户直接观察数据。

RNA-seq数据分析

RNA-seq数据与表达谱芯片数据在基因表达差异的显著性分析流程基本相同，不同的地方只在确定差异表达基因方面。

基因表达差异的显著性分析

表达差异分析只对比不同样本之间的同一个转录本，所以不需要考虑转录本长度，只考虑总读段数。一个最简单思想就是，样本测序得到的总读段数（实际上是可以比对到转录组的总读段数）越多，则每个基因分配到的读段越多。因此最简单的标准化因子就是总读段数，用总读段数作标准化的前提是大部分基因的表达是非显著变化的，这与基因芯片中的基本假设相同。但是实际工作中发现很多情况下总读段数主要是一小部分大量表达的基因贡献的。Bullard等（2010）在比较了几种标准化方法的基础上发现在每个泳道内使用非零计数分布的上四分位数（Q75%）作为标准化因子是一种更稳健的选择，总体表现是所研究方法中最优的。

Bioconductor的edgeR包和DESeq包分别提供了上四分位数和中位数来作为标准化因子，就是出于这个思想。

edgeR提供了三种标准化算法，分别是M值加权截断均值法（Weighted trimmed mean of M-values, TMM），相对对数表达值法（Relative log expression, RLE）和上四分位法（Upperquartile），其中TMM是默认设定。这些标准化方法大同小异，其基本思想就是去除表达值较大的少数基因的影响，而保留大部分没有显著变化的基因。

由于基因芯片检测杂交的荧光强度信号是连续值，往往假设它符合正态分布；而RNA-seq测量的是离散值，最简单的假设就是二项分布。由于RNA-seq读段数量非常多，而且一条读段映射到一个给定基因的概率足够小，在实际计算中，二项分布常用它的极限形式泊松分布来替代。泊松分布的一个性质是其方差等于均值，但是当有生物学重复时，RNA-seq数据会表现出比泊松分布期望的更高的变异性，对相当多的基因来说方差可能超过均值，这种现象叫过离散。对过离散数据，基于泊松分布假设的分析容易低估不同生物学重复带来的取样误差而得到过多的假阳性的差异表达基因。为了允许额外的变异，一个自然的想法就是给均值加上一个散度参数，以使方差可以大于均值。于是作为泊松分布的推广，又引入了负二项分布（NB）来作为基本假设，负二项分布是当前基因表达的显著性分析中最常用假设。

现在从百度百科摘取二项分布与负二项分布的公式，以加强理解。

二项分布，即重复n次的贝努利试验，用$\xi$表示随机试验的结果。如果事件发生的概率是p,不发生的概率是1-p，那么N次独立重复试验中发生k次的概率是：

$P(\xi=k)=C_n^k * p^k *(1-p)^{n-k}$

期望：$E_\xi = np$

方差： $D_\xi = npq$

而负二项分布的公式（概率密度）为：

$f(k; r, p)=P_r(x=k) = C_{k+r+1}^{r-1}*p^k*(1-p)^{n-k}$

它表示，已知一个事件在贝努利试验中每次的出现概率是p，在一连串贝努利试验中，一件事刚好在第r+k次试验出现第r次的概率。

写作：X ~ NB(r; p)

基于负二项分布的edgeR、DESeq包是当前最主要的分析程序。在edgeR中，对于任一样品i中的任一个基因g，假设它的分布符合负二项分布。

$Y_{gi} = NB(M_ip_{gj}, \phi_g)$

其中$M_i$是样品i中的读段总数（实际中是可以比对上的读段总数）；$\phi_g$就是基因g的散度；$p_{gj}$是基因g在某个实验条件j下或者分组j中的相对丰度。第g个基因在某个实验条件j下或分组j中，NB分布的均值为$\mu_{gj}=p_gjM_i$，方差为$\mu_{gj}(1+\mu_{gj}\phi_g)$，对于表达差异分析，需要估计的是散度$\phi_g$，当它趋于0时，负二项分布退化为泊松分布，这时方差退化为第一项$\mu_{gj}$，一般认为来自技术重复，方差第2项$\mu^2_{gj}\phi_g$来自生物学重复。

RNA-seq数据分析往往只有很小的样本量，为每个基因估计一个散度非常困难。比较好的策略是允许不同的基因有不同的个体散度，而这些个体散度的估计可以用一些合适的统计方法借助基因间的信息来改进。相对于edgeR，DESeq默认设置采取了最保守的估计策略，即选取每个基因的经验散度和拟合得到的散度趋势线取值中最大的作为最终的散度估计值，因此DESeq往往选出更少的差异表达基因（为什么呢？）。DESeq由于可以利用同一个样本基因间的数据估计散度，而不一定需要重复样本来计算，因此可以直接用于无重复实验的表达差异分析。

后面一些实例代码不好重复，不再描述。

下游分析方法可以参考上一篇博文对基因芯片数据的讲解。

dput函数 - 保存R的数据结构

2017-10-27T00:00:00+00:00

记住这个函数！记住这个函数！记住这个函数！ 重要的事情说三遍，为了让你能更清醒地记住，我再说一遍，记住这个函数！

dput是导出数据结构供重复使用的函数，这是跟别人交流或者请教问题的一个重要函数。比如你在用R分析的时候遇到问题了，有问题的是对某个列表或者数据框进行操作，该怎么让别人可以重复你的错误然后帮你找错呢？这就是这个函数存在的意义。

举个例子，假如你有这样一个数据框：

> staff
      name salary years_old
1 zhangsan   1200        20
2     lisi   2200        30
3   wangwu   3200        40

然后你想给每个人涨200块并更新表格，想做个简单计算：

> staff$salary <- staff$salary + 200
Error in staff$salary + 200 : non-numeric argument to binary operator

我擦，什么鬼，英文我不懂，想请教下别人怎么帮你解决，你这时候就用的上dput函数了。

于是你使用这个函数把数据存取，发布到给专家：

> dput(staff)
structure(list(name = structure(c(3L, 1L, 2L), .Label = c("lisi", 
"wangwu", "zhangsan"), class = "factor"), salary = c("1200", 
"2200", "3200"), years_old = c(20, 30, 40)), .Names = c("name", 
"salary", "years_old"), row.names = c(NA, -3L), class = "data.frame")

为了区别，专家用a表示staff把你的数据结构在他的电脑上重现：

> a <- structure(list(name = structure(c(3L, 1L, 2L), .Label = c("lisi", "wangwu", "zhangsan"), class = "factor"), salary = c("1200", 
+                 "2200", "3200"), years_old = c(20, 30, 40)), .Names = c("name", "salary", "years_old"), row.names = c(NA, -3L), class = "data.frame")

然后就可以帮你检查了：

> str(a)
'data.frame':	3 obs. of  3 variables:
 $ name     : Factor w/ 3 levels "lisi","wangwu",..: 3 1 2
 $ salary   : chr  "1200" "2200" "3200"
 $ years_old: num  20 30 40

喔~原来salary变量是字符向量，不能做数学运算。帮你修改：

> a$salary <- as.integer(a$salary)
> a$salary <- a$salary + 200 
> a
      name salary years_old
1 zhangsan   1400        20
2     lisi   2400        30
3   wangwu   3400        40

导出：

> dput(a)
structure(list(name = structure(c(3L, 1L, 2L), .Label = c("lisi", 
"wangwu", "zhangsan"), class = "factor"), salary = c(1400, 2400, 
3400), years_old = c(20, 30, 40)), .Names = c("name", "salary", 
"years_old"), row.names = c(NA, -3L), class = "data.frame")

然后你把结果拷贝并导回，工作完成：

> salary <- structure(list(name = structure(c(3L, 1L, 2L), .Label = c("lisi", 
+                                                                     "wangwu", "zhangsan"), class = "factor"), salary = c(1400, 2400, 
+                                                                                                                          3400), years_old = c(20, 30, 40)), .Names = c("name", "salary", 
+                                                                                                                                                                        "years_old"), row.names = c(NA, -3L), class = "data.frame")
> salary
      name salary years_old
1 zhangsan   1400        20
2     lisi   2400        30
3   wangwu   3400        40

Bioconductor分析基因芯片数据

2017-10-09T00:00:00+00:00

参考学习《R语言与Bioconductor——生物信息学应用》第五章，根据自己学习有删改，欢迎分享。本文中有些预备知识或一些方法的原理没有提及，请自行搜索理解或者购买该书学习。

Bioconductor最初就是设计来分析基因芯片数据的，因此芯片分析整体反映了Biocondutor的设计理念和编程思想。

快速入门

通过一个例子了解如何载入芯片数据，完成预处理，最后获得基因（探针组）表达矩阵。

# install CLL package
# library(BiocInstaller)
# biocLite("CLL")

# 载入CLL包，CLL包会自动调用affy包，该包含有一系列处理函数
library(CLL)
# read example dataset，（CLL包附带的示例数据集）
data("CLLbatch")
# pre-process using RMA method
CLLrma <- rma(CLLbatch)
# read expression value after pre-processing
e <- exprs(CLLrma)
# 查看部分数据
e[1:5, 1:5]

数据输出如下：

> e[1:5, 1:5]
          CLL10.CEL CLL11.CEL CLL12.CEL CLL13.CEL CLL14.CEL
100_g_at   7.495697  7.945159  7.861043  7.990252  7.889718
1000_at    7.251120  8.298723  8.473531  8.131041  8.051400
1001_at    4.457362  4.517529  4.357791  4.651236  4.473598
1002_f_at  3.984693  3.981675  4.065171  4.132480  4.065022
1003_s_at  6.437046  6.200826  6.412218  6.313572  6.105120

对象e是一个12625行、24列的基因表达矩阵。可以看到，我们仅用了不到10行代码就完成了整个芯片的预处理过程。

关于探针组

一张基因芯片包含上百万的探针，它们被整齐有序地印刷再芯片上。探针组（probe set）来自于一个基因，通常由20对或者11对探针组成。每一对探针都由匹配探针（PM）和错配探针组成，称为探针对。

探针序列地来源叫做参考序列，通常来自于公开的核酸数据库。不同的芯片类型，探针组在参考序列中的分布不同。

这里有一个概念误区需要注意：芯片数据中的基因表达矩阵往往是以探针组而不是以基因为单位的，每行都对应一个探针组的表达量。我们一般通过ID映射才对应到探针组代表的基因，它们的关系常常为多个探针组对应一个基因。实际应用中则不太注意区分。

关于芯片文件格式

芯片实验结果获取数据主要通过两个步骤，第一步由扫描设备对芯片进行扫描，得到荧光信号图像文件（DAT文件）；第二步由系统自带的图形处理软件进行一系列图形处理与识别，从芯片图像中提取数据，得到CEL文件。

Affymetrix芯片原始数据最常用格式为CEL格式，也是芯片数据预处理和分析的出发点。

CEL文件只提供了每个探针的灰度信息，还需要基因芯片探针排布的信息（哪个探针来自哪个探针组），才可以得到芯片上每个探针组对应的表达数据，这就需要CDF文件。另一个重要的文件是Probe文件，它提供了探针的序列信息。

除了上述提到的几种文件格式，常见的还有EXP文件、CHP文件、TXT文件和RPT文件。TXT文件特指包含基因表达矩阵的TXT文件，CHP文件与TXT文件内容基本相同。

数据预处理

预处理的目的是将探针水平的数据转换成基因表达数据。主要的数据结构有AffyBatch类和ExpressionSet类，前者用于存储探针水平数据（相当于CEL文件内容），而后者用于存储表达水平的数据（基因表达矩阵）。

预处理通过质量控制，剔除不合格的芯片数据，只保留合格的进入下一步处理。然后通过标准化，将所有芯片数据中的基因表达值变换到一个可以比较的水平，用于后续分析。

数据输入

实际应用中，常见情况是从CEL文件中获得数据。在上一个例子中，数据包CLL中得到的芯片数据基本等同于CEL文件。

无论是数据包还是文件输入，读入的数据会存入一个AffyBatch类型的对象中。

# load package
# library(CLL)

# load data
data(CLLbatch)

# view the data type
data.class(CLLbatch)

# load status info of all samples
data(disease)
# view
disease

# see help of AffyBatch
help("AffyBatch")

看一下输出的一些结果：

> data.class(CLLbatch)
[1] "AffyBatch"
> disease
   SampleID  Disease
   CLL10     <NA>
   CLL11 progres.
   CLL12   stable
   CLL13 progres.
   CLL14 progres.
   CLL15 progres.
   CLL16 progres.
   CLL17   stable
   CLL18   stable
  CLL19 progres.
   CLL1   stable
  CLL20   stable
  CLL21 progres.
  CLL22   stable
  CLL23 progres.
  CLL24   stable
   CLL2   stable
   CLL3 progres.
   CLL4 progres.
   CLL5 progres.
   CLL6 progres.
   CLL7 progres.
   CLL8 progres.
   CLL9   stable

CLL数据集存储了24位癌症病人样本的数据，所有病人根据健康状态分为两组：稳定期（Stable）组和进展组（Progressive）。

AffyBatch类

Biobase软件包中，AffyBatch类是从一个更基础的类eSet类衍生来的。eSet类非常重要，它被写成了一个虚类，衍生出许多非常重要的类，包括ExpressionSet类，SnpSet类以及AffyBatch类等。eSet是Bioconductor为基因表达数据格式所定制的标准，因此非常有必要熟悉eSet及其衍生类。

> phenoData(CLLbatch)
An object of class 'AnnotatedDataFrame'
  sampleNames: CLL10.CEL CLL11.CEL ... CLL9.CEL (24 total)
  varLabels: sample
  varMetadata: labelDescription
> featureData(CLLbatch)
An object of class 'AnnotatedDataFrame': none
> protocolData(CLLbatch)
An object of class 'AnnotatedDataFrame': none
> annotation(CLLbatch)
[1] "hgu95av2"
> exprs_matrix <- assayData(CLLbatch)[[1]]
> exprs_matrix[1:5, 1:5]
  CLL10.CEL CLL11.CEL CLL12.CEL CLL13.CEL CLL14.CEL
1     183.0     113.0     119.0     130.0     133.0
2   11524.8    6879.8    7891.3    8627.5    8205.3
3     301.0     146.0     133.0     160.0     153.0
4   11317.0    6747.0    7916.0    8616.0    7865.0
5     115.0      82.0      78.8     101.0      65.3
> exprs(CLLbatch)[1:5, 1:5]
  CLL10.CEL CLL11.CEL CLL12.CEL CLL13.CEL CLL14.CEL
1     183.0     113.0     119.0     130.0     133.0
2   11524.8    6879.8    7891.3    8627.5    8205.3
3     301.0     146.0     133.0     160.0     153.0
4   11317.0    6747.0    7916.0    8616.0    7865.0
5     115.0      82.0      78.8     101.0      65.3

assayData槽是AffyBatch类必不可少的，其方法返回结果的第一个元素是矩阵类型，用于保存基因表达矩阵。该矩阵的行对应不同的探针组，用一个无重复的索引值表示；列对应不同的样本。当使用exprs方法时，调取的就是这个基因表达矩阵。
experimentData槽是一个MIAME（Minimum Information About a Microarray Experiment）类型的数据，设计这个MIAME类的目的就是用于保存MIAME原则建议的注释信息。该原则建议了一组标准用来记录与基因芯片实验设计相关的资料。

结果中可以看到phenoData(CLLbatch)结果没有每个样品对应的表型信息。因为CLL包采用了一个数据框类型的变量disease来保存每个样本的表型信息。其实，将表型信息存入数据结构CLLbatch中是更为规范的做法。

质量控制

这里的质量控制主要集中在CEL文件级别的处理，从最简单的直接观察，到平均值方法，再到比较高级的数据拟合方法。这三个层次的质量控制功能分别由image函数、simpleaffy包和affyPLM包实现。

我们先直观地看一下芯片上所有位点的灰度图像。

# 查看第一张芯片的灰度图像
image(CLLbatch[,1])

芯片左上角的花纹和芯片名称可以帮助我们来了解芯片数据是否可靠。根据图像信息，可以对芯片的信号强度产生一个总体认识：图像特别黑，信号强度低；图像特别亮，信号可能过饱和。

很显然这种方法非常粗糙，不能量化。比它好的简单方法是基于各种平均值的方法。这类方法的一个共同特点就是假设一组实验中的每个芯片数据对于某个平均值指标都相差不大。Affymetrix公司在指导手册中进行了详细描述。

尺度因子（Scaling factor）：用于比较地芯片之间地尺度因子地比例必须小于3
检测值（Detection call）和检出率（Percent present）：一组探针能否被检测到，用检测值有（Present，简称P）、无（Absent，简称A）和不确定（Marginal present，简称M）来表示。
平均背景噪声（Average background）
标准内参（Internal control genes）:大部分的细胞有$\beta$-actin和GAPDH基因…

根据上述的这些标准，使用Bioconductor的simpleaffy包对Affymetrix芯片数据进行质量评估，最后得到质量控制总览图。

## use simpleaffy package
library(BiocInstaller)
biocLite("simpleaffy")
library(simpleaffy)
library(CLL)
data(CLLbatch)
# acquire analysis report
Data.qc <- qc(CLLbatch)
# visualize report
plot(Data.qc)

上图显示的是全部数据的质量控制总览图。第一列是所有样本的名称；第二列是两个数字，上面的是以百分比形式出现的检出率，下面的数字表明平均背景噪声。第三列（“QC Stats”）最下面的横轴是尺度因子等指标对应的坐标，取值范围从-3到3。第3列用到了三项指标：尺度因子、GAPDH 3’/5’ 比值和actin 3’/5’比值，分别用实心圆、空心圆和三角标志表示出来。如果出现红色的“bioB”字样，说明该样品中未能检测到BioB。

简单地讲，所有指标出现蓝色表示正常，红色表示可能存在质量问题。但这样根据实际情况进一步分析。一般来讲，如果有一个芯片各项指标都不太正常，尤其是BioB无法检测到，建议判定该芯片实验失败。比如CLL15.CEL这个数据的检出率明显低于其他样品，actin3/actin5远大于3，而且没有检测到BioB，因此数据可以判定为无效。

基于平均值假设的评价指标都有一个默认的假设，那就是对于每一块芯片，质量是均匀的，不会随位置不同发生较大的变化。但事实上，芯片的每一个小格之间的质量也是有差异的。

如何得到比较可靠的质量评估呢？这需要设计多种能反映芯片数据全貌的指标综合分析从而得到最终的结论。这些指标要在对原始数据拟合的基础上计算得到，以图形显示，包括权重残差图、相对对数表达箱线图、相对标准差箱线图、RNA降解曲线、聚类分析、主成分分析、信号强度分布图与MA图等等。以上功能可以通过affyPLM包实现。

## use affyPLM package
biocLite("affyPLM")
library(affyPLM)
library(CLL)
data(CLLbatch)
# 对数据集做回归分析，结果为一个PLMset类型的对象
Pset <- fitPLM(CLLbatch)
image(CLLbatch[,1])
# 根据计算结果，画权重图
image(Pset, type="weights", which=1, main="Weights")
# 根据计算结果，画残差图
image(Pset,  type="resids", which=1, main="Residuals")
# 根据计算结果，画残差符号图
image(Pset, type="sign.resids", which=1, main="Residuals.sign")

affyPLM包在探针水平拟合时引入了加权最小二乘法来进行回归，理论上，权重和残差的分布是随机的，应该看到绿色均匀分布的权重图和红蓝均匀分布的残差图。

相对对数表达箱线图（RLE）反映了基因表达量的一致性趋势，它定义为一个探针组在某个样品的表达值除以该探针组在所有样品中表达值的中位数后取对数。

如果使用RLE箱线图来控制CLL数据集的实验质量，每个样品的中心应该非常接近纵坐标0的位置。如果个别样品的表现与其他大多数明显不同，那说明可能这个样品可能有问题。下面我们根据这个数据集来看看。

## 
biocLite("RColorBrewer")
# library(affyPLM)
library(RColorBrewer)
colors <- brewer.pal(12, "Set3")
# RLE
Mbox(Pset, ylim=c(-1, 1), col=colors, main="RLE", las=3)
# NUSE
boxplot(Pset, ylim=c(0.95, 1.22), col=colors, main="NUSE", las=3)

NUSE是一种比RLE更为敏感的质量检测手段。我们可以结合NUSE图来确定是否某个芯片质量有问题。NUSE定义为一个探针组在某个样品的PM值的标准差除以该探针值在各样品中的PM标准差的中位数。如果所有芯片的质量都是非常可靠的话，那么它们的标准差会非常接近，因此它们的NUSE值都会在1附近。

然而，如果有些芯片质量有问题的话，就会严重地偏离1，进而导致其他芯片地NUSE值偏向相反的方向。当然，存在一种极端的情况，就是大部分芯片都出问题了，但是它们的标准差却比较接近，反而会显得没有质量问题的芯片的NUSE值会明显偏离1，所以必须结合两种图作出可靠的判断。

可以看到CLL1和CLL10的质量明显有别于其他样品，需要舍弃。

RNA降解是影响芯片质量的一个很重要因素。因为RNA是从5’端开始降解的，理论上5‘端的荧光强度应该低于3’端的荧光强度。如果RNA降解曲线的斜率太小，甚至接近于0，很可能是RNA降解太严重，需要作为坏数据去除（下图显示的CLL13）。

# RNA degradation
# library(affy)
data.deg <- AffyRNAdeg(CLLbatch)
plotAffyRNAdeg(data.deg, col=colors)
legend("topleft", rownames(pData(CLLbatch)), col=colors, lwd=1, inset=0.05, cex=0.5)

CLLbatch <- CLLbatch[, -match(c("CLL10.CEL", "CLL1.CEL", "CLL13.CEL"),
                              sampleNames(CLLbatch))]

去掉三个质量差的。

前面提到的质量控制方法都是基于平均值思想的，其实，我们还可以从芯片之间的相互关系来检验芯片的质量。理论上组内同种类型的芯片数据应该聚拢在一起，两个组之间应该明显地分离。Pearson线性相关系数就是最常用的这类指标，但在实际应用中，往往不是直接查看相关系数矩阵，而是根据由相关系数矩阵导出的距离矩阵，进行聚类分析或主成分分析以对样品归类并图形化显示。

## cluster and PCA
# install packages
biocLite("gcrma")
biocLite("graph")
biocLite("affycoretools")

# load packages
library(CLL)
library(gcrma)
library(graph)
library(affycoretools)

# load data
data(CLL)
data(disease)
# pre-process using gcrma
CLLgcrma <- gcrma(CLLbatch)
# retrieve gene expression dataset
eset <- exprs(CLLgcrma)
# compute Pearson corr coeffience
pearson_cor <- cor(eset)
dist.lower <- as.dist(1 - pearson_cor)
# cluster
hc <- hclust(dist.lower, "ave")
# plot
plot(hc)
# PCA
samplenames <- sub(pattern = "\\.CEL", replacement = "", colnames(eset))
groups <- factor(disease[,2])
plotPCA(eset, addtext=samplenames, groups=groups, groupnames=levels(groups))

从聚类分析的结果来看，稳定组和恶化组根本不能很好分开。这还不能判定实验失败。理论上讲，如果总体上两组数据是分开的，那么说明我们关心的导致癌症从稳定到恶化的因素起到了主要因素。如果不是，需要具体问题具体分析。CLL数据的实验样本来自不同个体，而不是细胞，很可能个体差异起到了主导作用，因此导致聚类被整体打乱。所以只有当聚类图中有明显的类别差异时，才适合考虑去除个别不归类的样品；如果整体分类被打乱，则不能简单判定所有样品都出了问题。

芯片分析往往采用两个主成分来构建分类图，我们从下图可以看出两组根本就不能很好分开。

注意，使用主成分分析时，还必须考虑前2个主成分是否具有代表性，这要看前2个主成分的累计贡献率，如果低于60%，可以考虑采用多维尺度分析来构建分类图。

背景校正、标准化和汇总

芯片数据通过质量控制，剔除不合格的样品，留下的数据经过背景校正、标准化和汇总三步得到下一步分析用的基因表达矩阵。

实际中经常发现大量的MM（Mismatch）信号比PM（Perfect Match）信号还要高。我们需要应用复杂的统计模型来去除背景噪声，这叫作背景校正（Background correction）。

标准化的目的是消除测量间的非实验误差，使得实验条件下的测量可以相互比较。芯片数据标准化根据基本假设分为“bulk normalization”与”control-based normalization”两种。前者假定仅有一小部分基因表达值在不同条件下有差异，因此使用所有的基因表达值作为参考进行标准化；后者使用表达值被认为恒定不变的参考基因作为标准进行标准化。实际应用中一般只采用第一种。

最后，我们使用一定的统计方法将前面得到的荧光强度值从探针水平汇总到探侦组水平，这个过程被称为汇总（Summarization）。

上述三个步骤可以由affy包的expresso函数实现，我们可以设定不同的参数来指定具体采用的方法。

# 在前面分析的基础上
eset.mas <- expresso(CLLbatch, bgcorrect.method = "mas", normalize.method = "constant", pmcorrect.method = "mas",
                     summary.method = "mas")

可以看到函数的调用非常简单，但参数很多，理解比较复杂。想要了解所有参数的含义，使用help(expresso)命令获取参数说明。

下面命令可以查看可选的参数：

> bgcorrect.methods()
[1] "bg.correct" "mas"        "none"       "rma"       
> normalize.methods(CLLbatch)
 [1] "constant"           "contrasts"          "invariantset"       "loess"              "methods"            "qspline"           
 [7] "quantiles"          "quantiles.robust"   "quantiles.probeset" "scaling"           
> pmcorrect.methods()
[1] "mas"        "methods"    "pmonly"     "subtractmm"
> express.summary.stat.methods()
[1] "avgdiff"      "liwong"       "mas"          "medianpolish" "playerout"  

参数	说明
afbatch	输入数据的类型必须是AffyBatch对象
bgcorrect.method	背景校正方法
bgcorrect.param	指定背景校正方法的参数
normalize.method	标准化方法
normalize.param	指定标准化方法的参数
pmcorrect.method	PM调整方法
pmcorrect.param	指定PM方法参数
summary.method	汇总方法
summary.param	指定汇总方法的参数

八种十种标准方法，又可以分为芯片间标准方法和芯片内标准化方法。芯片间标准化方法针对单通道芯片数据，常用的有三种：线性缩放（constant）、不变集（invariantset）和分位数方法（quantiles）。芯片间标准方法的核心思想就是确定一个参考芯片（可以是假想的），假定芯片之间的某种不变量，对其他芯片数据进行整体的拉伸或者压缩变换。线性缩放方法，以其他芯片和参考芯片（默认为第一个）所有基因表达值均值的比值为因子，对其他芯片的表达值做等比例缩放。这个方法非常简单，是MAS5预处理算法默认使用的标准化方法。MAS5预处理算法不指定任何芯片，而是设定了一个假想的芯片均值作为参考，这样每个芯片都可以单独计算，有新的数据加入时也可以不必重新计算已经标准化的数据。分位数方法是RMA预处理算法默认使用的标准化方法（关于方法的使用应该根据数据合理选择，网上搜索方法使用的具体详情，这里书里没有进行过多的阐述）。

下面用MAS方法进行背景校正和标准化：

# 使用mas方法做背景校正
> CLLmas5 <- bg.correct(CLLbatch, method = "mas")
# 使用constant方法标准化
> data_mas5 <- normalize(CLLmas5, method="constant")
#　查看每个样品的缩放系数
> head(pm(data_mas5)/pm(CLLmas5), 5)
       CLL11.CEL CLL12.CEL CLL14.CEL CLL15.CEL CLL16.CEL CLL17.CEL CLL18.CEL CLL19.CEL CLL20.CEL CLL21.CEL CLL22.CEL CLL23.CEL
175218         1  1.155849  1.023873  1.493193  1.549369  2.000299  1.451576  1.776501 0.9825108 0.7070828 0.9958733  1.432365
356689         1  1.155849  1.023873  1.493193  1.549369  2.000299  1.451576  1.776501 0.9825108 0.7070828 0.9958733  1.432365
227696         1  1.155849  1.023873  1.493193  1.549369  2.000299  1.451576  1.776501 0.9825108 0.7070828 0.9958733  1.432365
237919         1  1.155849  1.023873  1.493193  1.549369  2.000299  1.451576  1.776501 0.9825108 0.7070828 0.9958733  1.432365
275173         1  1.155849  1.023873  1.493193  1.549369  2.000299  1.451576  1.776501 0.9825108 0.7070828 0.9958733  1.432365
       CLL24.CEL CLL2.CEL  CLL3.CEL  CLL4.CEL  CLL5.CEL CLL6.CEL CLL7.CEL CLL8.CEL  CLL9.CEL
175218  1.706026 1.156378 0.8425419 0.9775082 0.9816573 1.182963 1.114976  1.13639 0.8939248
356689  1.706026 1.156378 0.8425419 0.9775082 0.9816573 1.182963 1.114976  1.13639 0.8939248
227696  1.706026 1.156378 0.8425419 0.9775082 0.9816573 1.182963 1.114976  1.13639 0.8939248
237919  1.706026 1.156378 0.8425419 0.9775082 0.9816573 1.182963 1.114976  1.13639 0.8939248
275173  1.706026 1.156378 0.8425419 0.9775082 0.9816573 1.182963 1.114976  1.13639 0.8939248
# 查看第二个样品的缩放系数是怎么计算来的
> mean(intensity(CLLmas5)[,1])/mean(intensity(CLLmas5)[,2])
[1] 1.155849

芯片内标准化方法针对双通道芯片数据，又可以分为全局化方法（Global normalization）和荧光强度依赖的方法（Intensity-dependent normalization）。

全局化方法假设红色染料的信号强度与绿色染料的信号强度是正比例关系的，即R=kG（R：红色信号强度；G：绿色信号强度）。

MA（M代表Minus，A代表Average）图全称为：The distribution of the red/green intensity ratio plotted by the average intensity。定义$M=log_2(R/G)，A=1/2log_2(RG)$。此处R和G已经不再特指双通道cDNA芯片中红和绿标记的样品表达量，可以表示任何两个需要对比的数据。单通道数据中MA图反应了基因在对比的样品中表达差异（对数化的）随基因信号强度（对数化的）变化的分布。

当数据符合全局化方法的假设，数据标准化后的MA图大多数基因的差异表达值（M值）应该对称分布在水平的中心线（M=0）附近。若此方法不成立，只能采用荧光强度依赖的方法，将M调整为以0为中心的分布，这类方法最常用的是Loess方法。简单来说就是对不同的A值的基因进行局部加权回归，得到一条蓝色的直线。不过现在已经很少有人用双通道cDNA芯片了。

预处理的一体化算法

除了expresso函数，affyPLM软件包提供了threestep函数可以更快地实现同样的功能。如果我们自己自行组合参数，实际上使用可能会很低效，甚至有些组合不能使用。因此实际中，应用较多的预设参数的一体化算法，我们可以完全不管细节，直接使用从而简化处理和分析过程。

预处理方法

方法	背景校正方法	标准化方法	汇总方法
MASS	mas	constant	mas
dChip	mas	invariantset	liwong
RMA	rma	quantile	medianpolish

常见的预处理算法一般都已经按照同名函数包装好以供调用，如affy包的MAS5和RMA，gcrma包的gcRMA（基于RMA算法）等。

实际工作中，MAS5和RMA算法使用较多。下面对差异做一个比较：

MAS5 每个芯片可以单独进行标准化；RMA 采用多芯片模型，需要对所有芯片一起进行标准化。
MAS5 利用MM探针的信息去除背景噪声，基本思路是MP-MM；RMA 不使用MM信息，而是基于PM信号分布采用的随机模型来估计表达值。
RMA处理后的数据是经过2为底的对数转换的，而MAS5不是，这一点非常重要，因为大多数芯片分析软件和函数的输入数据必须经过对数变换。

下面我们来比较不同算法的处理效果。

library(affy)
library(gcrma)
library(affyPLM)
library(RColorBrewer)
library(CLL)

data("CLLbatch")
colors <- brewer.pal(12, "Set3")
# use MAS5
CLLmas5 <- mas5(CLLbatch)
# use rma 
CLLrma <- rma(CLLbatch)
# use gcrma
CLLgcrma <- gcrma(CLLbatch)

## hist plot
hist(CLLbatch, main="orignal", col=colors)
legend("topright", rownames(pData(CLLbatch)), col=colors,
       lwd=1, inset=0.05, cex=0.5, ncol=3)
hist(CLLmas5, main="MAS 5.0", xlim=c(-150,2^10), col=colors)
hist(CLLrma, main="RMA", col=colors)
hist(CLLgcrma, main="gcRMA", col=colors)
## boxplot
boxplot(CLLbatch, col=colors, las=3, main="original")
boxplot(CLLmas5, col=colors, las=3, ylim=c(0,1000), main="MAS 5.0")
boxplot(CLLrma, col=colors, las=3, main="RMA")
boxplot(CLLgcrma, col=colors, las=3, main="gcRMA")

先看信号强度分布图

这里简要说明：RMA算法将多条曲线重合到了一起，有利于进一步的差异分析，但却出现了双峰现象，不符合高斯正态分布。很显然gcRMA算法在这里表现的更好。当然，这不意味着gcRMA算法总是优越于RMA算法。

下面看箱线图结果：

三个算法处理后的各样品的中值都十分接近。MAS5算法总体而言还不错，有一定拖尾现象；而gcRMA的拖尾现象比RMA要明显得多。这说明针对低表达量的基因，RMA算法比gcRMA算法表现更好一些。

最后我们可以通过MA图来查看标准化处理的效果。

原始数据中，中值（红线）偏离0，经过gcRMA处理后，中值基本保持在零线上。

基因芯片数据分析

通过以下几个实例，掌握Bioconductor处理芯片数据的完整过程。

选取差异表达基因

这是非常关键也是为人所熟知的一步，即使没有数据分析背景的生物学方向学生也必然不会对此陌生。而生物实验往往想要找的就是差异表达基因。

总的来说，这类分析的基本假设是标准化的芯片数据符合正态分布（想想为什么正式分析数据前要做那么多步骤处理？），所用的统计方法基本上就是T/F检验和方差分析以及它们的改进方法。

这里不再详细介绍各类方法，现在经验贝叶斯是当前最常用的分析方法，它已经完整地由Bioconductor中的limma包实现。limma包是基于R和Bioconductor平台分析芯片数据的综合软件包，该包功能齐全、教程完善、使用率极高，几乎成了芯片数据处理流程的代名词（说明分析用它准没错了）。

下面是应用该包计算CLL数据集中差异表达基因的流程。

####
#### DEG analysis

#　如果没有安装limma包，请取消下面两行注释
# library(BiocInstaller)
# biocLite("limma")

# 导入包
library(limma)
library(gcrma)
library(CLL)

# 导入CLL数据
data("CLLbatch")
data(disease)

# 移除 CLL1, CLL10, CLL13
CLLbatch <- CLLbatch[, -match(c("CLL10.CEL", "CLL1.CEL", "CLL13.CEL"),
                              sampleNames(CLLbatch))]
# 用gcRMA算法进行预处理
CLLgcrma <- gcrma(CLLbatch)

# remove .CEL in sample names
sampleNames(CLLgcrma) <- gsub(".CEL$", "", sampleNames(CLLgcrma))
# remove record in data disease about CLL1, 10 and 13.CEL
disease <- disease[match(sampleNames(CLLgcrma), disease[, "SampleID"]), ]

# 获得余下21个样品的基因表达矩阵
eset <- exprs(CLLgcrma)

# 提取实验条件信息
disease <- factor(disease[, "Disease"])

# 构建实验设计矩阵
design <- model.matrix(~-1+disease)
# 构建对比模型，比较两个实验条件下表达数据
#　这里的.是简写而不是运算符号
contrast.matrix <- makeContrasts(contrasts = "diseaseprogres. - diseasestable",
                                 levels=design)

# 线性模型拟合
fit <- lmFit(eset, design)
# 根据对比模型进行差值计算 
fit1 <- contrasts.fit(fit, contrast.matrix)
# 贝叶斯检验
fit2 <- eBayes(fit1)

# 生成所有基因的检验结果报告
dif <- topTable(fit2, coef="diseaseprogres. - diseasestable", n=nrow(fit2), lfc=log2(1.5))
# 用P.Value进行筛选，得到全部差异表达基因
dif <- dif[dif[, "P.Value"]<0.01,]
# 显示一部分报告结果
head(dif)

> head(dif)
              logFC  AveExpr         t      P.Value adj.P.Val         B
39400_at -0.9997850 5.634004 -5.727329 1.482860e-05 0.1034544 2.4458354
1303_at  -1.3430306 4.540225 -5.596813 1.974284e-05 0.1034544 2.1546350
33791_at  1.9647962 6.837903  5.400499 3.047498e-05 0.1034544 1.7135583
36131_at  0.9574214 9.945334  5.367741 3.277762e-05 0.1034544 1.6396223
37636_at  2.0534093 5.478683  5.120519 5.699454e-05 0.1439112 1.0788313
36122_at  0.8008604 7.146293  4.776721 1.241402e-04 0.2612118 0.2922106

下面逐次介绍这个分析过程的六个关键步骤：构建基因表达矩阵、构建实验设计矩阵、构建对比模型（对比矩阵）、线性模型拟合、贝叶斯检验和生成结果报表。

构建基因表达矩阵时，需要注意limma包对输入数据要求是必须经过对数转换的表达值。如果使用的预处理算法没有该处理过程，我们需要自行编写代码处理。

实验设计矩阵需要调用model.matrix函数构建，该函数需要用户指定一个公式，构建好的实验设计矩阵design要提供给下一步的拟合函数lmFit。

> design
   diseaseprogres. diseasestable
              1             0
              0             1
              1             0
              1             0
              1             0
              0             1
              0             1
              1             0
              0             1
             1             0
             0             1
             1             0
             0             1
             0             1
             1             0
             1             0
             1             0
             1             0
             1             0
             1             0
             0             1
attr(,"assign")
[1] 1 1
attr(,"contrasts")
attr(,"contrasts")$disease
[1] "contr.treatment"

实验设计矩阵的每一行对应一个样品的编码，每一列对应样品的一个特征。这里只考虑了一个因素两个水平，如果是多因素和多水平的实验设计，会产生更多的特征，需要参考文档设计。

比较模型需要调用makeContrasts函数构建，该函数需要用户指定一个公式，这个公式表明用户要求对实验矩阵design中的哪一列特征和哪一列特征进行比较，以得到差异。

接下来是根据实验设计矩阵调用函数对基因表达矩阵做线性拟合lmFit(eset, design)，根据对比模型进行差值计算，最后是贝叶斯检验。

topTable函数的使用需要注意几点：

topTable提供了多种方法可以做基因筛选，本例就通过对数化的变化倍数“lfc”去掉了一些在两组条件下变化不大的基因，但是这样做的理由不够充分，因为变化倍数不大的不一定就是没有显著变化。
topTable还提供了参数可以对基因进行排序。
显著性基因的选取具有一定主观性，阈值设定是0.01还是0.05没有严格标准。

此处分析步骤，还可以参考【R高级教程】专题二：差异表达基因的分析理解学习和实践。

注释

找到差异表达基因之后，接下来是使用注释包对其进行注释（因为我们现在找到的是探针组）。

对Affymetrix芯片进行注释采用下载对应平台注释包进行本地注释的方式。下面例子只用两种基因ID来对探针组进行注释。

# 加载注释工具包
library(annotate)

# 获得基因芯片注释包名称
affydb <- annPkgName(CLLbatch@annotation, type="db")
affydb
# 如果没有安装，先安装
biocLite(affydb)
#　加载该包
library(affydb, character.only = TRUE)
# 根据每个探针组的ID获取对应基因Gene Symbol，并作为新的一列
dif$symbols <- getSYMBOL(rownames(dif), affydb)
# 根据探针ID获取对应基因Entrez ID
dif$EntrezID <- getEG(rownames(dif), affydb)
# 显示前几行
head(dif)

> head(dif)
              logFC  AveExpr         t      P.Value adj.P.Val         B symbols EntrezID
39400_at -0.9997850 5.634004 -5.727329 1.482860e-05 0.1034544 2.4458354 TBC1D2B    23102
1303_at  -1.3430306 4.540225 -5.596813 1.974284e-05 0.1034544 2.1546350  SH3BP2     6452
33791_at  1.9647962 6.837903  5.400499 3.047498e-05 0.1034544 1.7135583   DLEU1    10301
36131_at  0.9574214 9.945334  5.367741 3.277762e-05 0.1034544 1.6396223   CLIC1     1192
37636_at  2.0534093 5.478683  5.120519 5.699454e-05 0.1439112 1.0788313   JADE3     9767
36122_at  0.8008604 7.146293  4.776721 1.241402e-04 0.2612118 0.2922106    <NA>     <NA>

注释实质上是一个ID映射过程，这里是将芯片探侦组的ID映射到基因国际标准名称（Gene symbol）和Entrez ID两种ID上。

Gene symbol是由人类基因命名委员会（The HUGO Gene Nomenclature Committee, HGNC）为每个人类基因提供的唯一命名，一般是大写拉丁字母缩写形式，后面可以加数字，以便于人工阅读。Entrez ID是NCBI的GI（GeneInfo Identifier）。NCBI对于每一条提交的序列，根据其存入NCBI数据时的先后顺序赋给一个整数，这就是GI。这里映射GI的目的是为了将GI映射到基因本体论（GO），然后做GO的富集分析。

统计分析及可视化

对于差异表达分析，最主要的两种统计分析就是GO的富集分析和KEGG通路的富集分析。它们分别由GOstats包和GeneAnswers包实现。

# 加载包
library(GOstats)
# 提取HG_U95Av2芯片中所有探针组对应的EntrezID，注意保证uniq
entrezUniverse <- unique(unlist(mget(rownames(eset), hgu95av2ENTREZID)))
# 提取差异表达基因及其对应的EntrezID
entrezSelected <- unique(dif[!is.na(dif$EntrezID), "EntrezID"])

# 设置GO富集分析的所有参数
params <- new("GOHyperGParams", geneIds=entrezSelected, universeGeneIds=entrezUniverse,
              annotation=affydb, ontology="BP", pvalueCutoff=0.001, conditional=FALSE,
              testDirection="over")
# 对所有的GOterm根据params参数做超几何检验
hgOver <- hyperGTest(params)

# 生成所有GOterm的检验结果报表
bp <- summary(hgOver)

# 同时生成所有GOterm的检验结果文件，每个GOterm都有指向官方网站的链接，以获得详细信息
htmlReport(hgOver, file="ALL_go.html")

# 显示结果前几行
head(bp)

> head(bp)
      GOBPID       Pvalue OddsRatio  ExpCount Count Size                                                     Term
GO:0022904 8.956477e-10  16.22041 0.8868343    11   66                     respiratory electron transport chain
GO:0022900 1.059675e-09  15.92875 0.9002712    11   67                                 electron transport chain
GO:0042773 3.220076e-09  17.09865 0.7659024    10   57                 ATP synthesis coupled electron transport
GO:0042775 3.220076e-09  17.09865 0.7659024    10   57   mitochondrial ATP synthesis coupled electron transport
GO:0006123 8.147710e-09  66.54092 0.1746795     6   13 mitochondrial electron transport, cytochrome c to oxygen
GO:0006119 1.917217e-08  13.83664 0.9137081    10   68                                oxidative phosphorylation

# 安装并加载所需包
biocLite("GeneAnswers")
library(GeneAnswers)

# 选取dif中的三列信息构成新的矩阵，新一列必须是EntrezID
humanGeneInput <- dif[, c("EntrezID", "logFC", "P.Value")]
# 获得humanGeneInput中基因的表达值
humanExpr <- eset[match(rownames(dif), rownames(eset)), ]
humanExpr <- cbind(humanGeneInput[,"EntrezID"], humanExpr)
# 去除NA数据
humanGeneInput <- humanGeneInput[!is.na(humanGeneInput[, 1]),]
humanExpr <- humanExpr[!is.na(humanExpr[,1]),]
# KEGG通路的超几何检验
y <- geneAnswersBuilder(humanGeneInput, "org.Hs.eg.db", categoryType = "KEGG",
                        testType = "hyperG", pvalueT=0.1, geneExpressionProfile=humanExpr,
                        verbose = FALSE)
getEnrichmentInfo(y)[1:6]

> getEnrichmentInfo(y)[1:6]
      genes in Category percent in the observed List percent in the genome fold of overrepresents odds ratio      p value
              12                   0.22222222           0.022150281              10.032479  13.794189 1.302401e-09
              13                   0.24074074           0.028454592               8.460523  11.655527 2.022230e-09
              11                   0.20370370           0.022491055               9.057099  12.038055 2.061276e-08
              12                   0.22222222           0.031180780               7.126897   9.430242 6.436589e-08
               7                   0.12962963           0.013119782               9.880471  12.223404 5.483387e-06
              22                   0.40740741           0.192537059               2.115995   2.920634 2.073075e-04
               3                   0.05555556           0.003748509              14.820707  17.944272 1.002054e-03
               6                   0.11111111           0.021639121               5.134733   5.882231 1.006287e-03
               4                   0.07407407           0.025558017               2.898272   3.106301 4.837838e-02
               4                   0.07407407           0.027602658               2.683585   2.864304 6.095794e-02
               2                   0.03703704           0.007497018               4.940236   5.286630 6.149150e-02
               3                   0.05555556           0.019083319               2.911210   3.079331 8.335034e-02
               2                   0.03703704           0.009712046               3.813515   4.027972 9.628046e-02

上面调用GeneAnswers包实现了KEGG通路的注释、统计和可视化的功能。GeneAnswers功能强大，还支持GO、REACTOME和CABIO等多个数据库，可以通过设定参数categoryType分别指定注释类型。

根据已有的计算，我们接下来可视化分析结果，调用pheatmap包来绘制差异表达谱热图；调用Rgraphviz包会绘制显著富集的GO term的关系图；最后绘制显著富集的KEGG通路的关系图和热图。

biocLite("pheatmap")
library(pheatmap)
# 从基因表达矩阵中，选取差异表达基因对应的数据
selected <- eset[rownames(dif), ]
# 将selected矩阵每行的名称由探针组ID转换为对应的基因symbol
rownames(selected) <- dif$symbols
# 考虑显示问题，这里只画前20个基因的热图
pheatmap(selected[1:20,], color = colorRampPalette(c("green", "black", "red"))(100),
         fontsize_row = 4, scale = "row", border_color = NA)

热图

(截图原因，没有显示完全)

biocLite("Rgraphviz")
library(Rgraphviz)
# 显著富集的GO term的DAG关系图
ghandle <- goDag(hgOver)
# 这个图太大，这里只能选一部分数据构建局部图
subGHandle <- subGraph(snodes=as.character(summary(hgOver)[,1]), graph = ghandle)
plot(subGHandle)

显著富集的GO term关系图

# 显著富集的KEGG通路的关系图
yy <- geneAnswersReadable(y, verbose = FALSE)
geneAnswersConceptNet(yy, colorValueColumn = "logFC", centroidSize = "pvalue",
                      output = "interactive")
# 显著富集的KEGG通路的热图
yyy <- geneAnswersSort(yy, sortBy = "pvalue")
geneAnswersHeatmap(yyy)

（这里两个结果图因为我的依赖包配置有问题，还没有解决，大家可以自己试试。）

总结

系统地走了一下基因芯片分析的流程，我们可以看到数据的分析主要分为两大块：预处理和分析。我们凭感觉往往侧重于分析，因为它们最靠近我们想要获得的结果。但从内容的介绍来看，我们可以观察到预处理部分富含更多的内容。分析的方法往往在短时间内会固化，近十年主流的分析过程主要的也就是提到的这几个，但是每个人想要处理的数据集是丰富多变的，它往往也决定了我们结果的可靠性。这是我们在分析时非常需要关注的一点。

最后输出会话信息：

> sessionInfo()
R version 3.4.1 (2017-06-30)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Ubuntu 17.04

Matrix products: default
BLAS: /home/diviner-wsx/anaconda3/lib/R/lib/libRblas.so
LAPACK: /home/diviner-wsx/anaconda3/lib/R/lib/libRlapack.so

locale:
 [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C               LC_TIME=en_US.UTF-8        LC_COLLATE=en_US.UTF-8    
 [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8    LC_PAPER=en_US.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C             LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       

attached base packages:
 [1] grid      stats4    parallel  stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
 [1] Rgraphviz_2.20.0     GeneAnswers_2.18.0   RColorBrewer_1.1-2   Heatplus_2.22.0      MASS_7.3-47          RSQLite_2.0         
 [7] annotate_1.54.0      XML_3.98-1.9         RCurl_1.95-4.8       bitops_1.0-6         igraph_1.1.2         GOstats_2.42.0      
[13] Category_2.42.1      Matrix_1.2-11        AnnotationDbi_1.38.2 IRanges_2.10.4       S4Vectors_0.14.6     graph_1.54.0        
[19] limma_3.32.8         affy_1.54.0          Biobase_2.36.2       BiocGenerics_0.22.1 

loaded via a namespace (and not attached):
 [1] Rcpp_0.12.13           BiocInstaller_1.26.1   compiler_3.4.1         tools_3.4.1            zlibbioc_1.22.0       
 [6] digest_0.6.12          bit_1.1-12             memoise_1.1.0          preprocessCore_1.38.1  tibble_1.3.4          
[11] lattice_0.20-35        pkgconfig_2.0.1        rlang_0.1.2            DBI_0.7                downloader_0.4        
[16] genefilter_1.58.1      bit64_0.9-7            GSEABase_1.38.2        RBGL_1.52.0            survival_2.41-3       
[21] magrittr_1.5           GO.db_3.4.1            blob_1.1.0             splines_3.4.1          AnnotationForge_1.18.2
[26] xtable_1.8-2           affyio_1.46.0         