管道与重定向进阶：stdin/stdout/stderr/文件描述符

生信流程本质是数据在管道中流动：FASTQ → 质控 → 比对 → SAM → 排序 → BAM → 定量 → 计数矩阵 → 差异表达。每一步都是 stdin → tool → stdout。理解管道和重定向不只是语法技巧，而是理解整个流程数据流的基础。

本文不讲 | 和 > 的基础语法，聚焦 进程替换、tee 分流、命名管道、文件描述符操作 等进阶技巧，覆盖 SAM 排序压缩、FASTQ 质控过滤、批量 GFF 处理等场景。

实测环境：Debian 12，Bash 5.2.32。

1. 三兄弟：stdin、stdout、stderr#

每个 Linux 进程生来就有三个文件描述符：

描述符	名称	编号	默认指向	生信用途
stdin	标准输入	0	键盘	管道传入的数据
stdout	标准输出	1	屏幕	正常结果（FASTQ、BAM、TSV）
stderr	标准错误	2	屏幕	日志、警告、进度信息

理解了这个，重定向语法就一通百通：

1
# 基础重定向
2
command > file         # stdout → file（覆盖）
3
command >> file        # stdout → file（追加）
4
command < file         # file → stdin
5
command 2> file        # stderr → file
6
command 2>&1           # stderr → stdout（合并到同一个流）
7
command &> file        # stdout + stderr → file（Bash 4.0+）
8

9
# 生信中最常见的模式
10
samtools view -bS aligned.sam > aligned.bam 2> samtools.log
11
# stdout（BAM 内容）→ aligned.bam
12
# stderr（日志）→ samtools.log

1.1 进程视角的公式#

如果用数学表达一个进程的 I/O 模型：

$\text{Process}: (fd_0, fd_1, fd_2) \xrightarrow{\text{transform}} \text{output}$

Shell 的 > 和 < 就是重新绑定 $fd_1$ 和 $fd_0$ 的目的地：

$fd_1 \leftarrow \text{file} \quad \text{instead of terminal}$

2. 管道——生信流程的骨架#

2.1 管道的基础模型#

1
# 管道连接 stdout → stdin
2
samtools view aligned.bam | head -100
3

4
# 等价于：
5
# samtools view 的 stdout → head 的 stdin

管道的理论基础是生产者-消费者模型：

$P_{throughput} = \min(\text{producer\_rate}, \text{consumer\_rate})$

如果前一步（producer）快、后一步（consumer）慢，管道会自动缓冲（默认 64KB）。如果前一步慢、后一步快，消费者会阻塞等待。管道的速度由最慢的步骤决定。

2.2 生信管道实战场景#

1
# 场景1：FASTQ 质控 + 比对一气呵成
2
fastp -i R1.fastq.gz -I R2.fastq.gz --stdout 2> fastp.log \
3
    | bwa mem -t 8 -p /opt/refs/hg38.fa - 2> bwa.log \
4
    | samtools sort -@ 4 -o aligned.sorted.bam - 2> sort.log
5

6
# 这里用了三个技巧：
7
# 1. fastp --stdout：输出到 stdout 而非文件
8
# 2. bwa mem 用 - 表示从 stdin 读取
9
# 3. samtools sort 也用 - 从 stdin 读
10

11
# 场景2：统计 BAM 中每条染色体的 reads 数
12
samtools idxstats aligned.bam \
13
    | awk '$3 > 0' \
14
    | sort -k3 -nr \
15
    | head -10
16

17
# 场景3：从 VCF 中提取高质量 SNP 并统计
18
bcftools view -i 'QUAL>30 && TYPE="snp"' variants.vcf.gz \
19
    | bcftools query -f '%CHROM\t%POS\t%REF\t%ALT\n' \
20
    | wc -l

3. tee——数据流的分叉器#

tee 把 stdin 复制两份：一份继续走管道，一份写入文件。比喻就是河流分叉：

1
# 在管道中间"偷看"数据，同时保存
2
samtools view aligned.bam \
3
    | tee intermediate.sam \
4
    | awk '{print $3}' \
5
    | sort | uniq -c | sort -rn \
6
    | tee chr_stats.txt \
7
    | head -10
8

9
# 第一条 tee：把 SAM 内容保存到文件，同时继续传给 awk
10
# 第二条 tee：把统计结果保存，同时传给 head 显示

3.1 同时输出到 stdout 和 stderr#

1
# 用进程替换，tee 把日志同时打到终端和文件
2
samtools view -bS aligned.sam 2>&1 | tee samtools.log
3
# 2>&1 先把 stderr 合并到 stdout，tee 再复制

3.2 多个文件 + 管道#

1
# 同时写入多个文件（生信：备份 + 继续处理）
2
cat sample_list.txt \
3
    | tee >(grep "^S[0-9]" > samples.txt) \
4
    | tee >(grep "^C[0-9]" > controls.txt) \
5
    > all.txt
6
# >(...) 是进程替换——把命令当作"文件"

4. 进程替换——最被低估的 Bash 特性#

4.1 本质#

进程替换 <(command) 和 >(command) 创建一个匿名管道（named pipe 的一种），把命令的 stdout/stdin 伪装成文件路径：

1
# 不用临时文件直接比较两个命令的输出
2
diff <(cut -f1 file1.txt | sort) <(cut -f1 file2.txt | sort)
3

4
# 等价但无需中间文件：
5
# cut -f1 file1.txt | sort > /tmp/file1_sorted
6
# cut -f1 file2.txt | sort > /tmp/file2_sorted
7
# diff /tmp/file1_sorted /tmp/file2_sorted
8
# rm /tmp/file1_sorted /tmp/file2_sorted

4.2 生信场景#

1
# 场景1：比较两个样本的基因列表（不生成中间文件）
2
comm -12 \
3
    <(awk '$8>0 {print $1}' sample1_counts.tsv | sort) \
4
    <(awk '$8>0 {print $1}' sample2_counts.tsv | sort) \
5
    > common_genes.txt
6

7
# 场景2：快速检查两个 BAM 文件的 header 差异
8
diff <(samtools view -H sample1.bam) <(samtools view -H sample2.bam)
9

10
# 场景3：GFF 和 BED 坐标交集（不需要中间文件）
11
bedtools intersect \
12
    -a <(awk '$3=="gene"' annotation.gff3 | gff2bed) \
13
    -b <(awk '$5>10' peaks.bed) \
14
    > overlapping_genes.bed
15

16
# 场景4：把 stderr 也送入管道处理
17
samtools flagstat aligned.bam 2> >(grep "mapped" > mapping_stats.txt)

5. 命名管道——跨进程通信#

5.1 创建和使用#

1
# 创建命名管道（FIFO）
2
mkfifo my_pipe
3

4
# 终端1：写入端
5
gzip -c huge.fastq > my_pipe
6

7
# 终端2：读取端（另一个终端/进程）
8
bwa mem ref.fa my_pipe > aligned.sam
9

10
# 清理
11
rm my_pipe

5.2 生信实战——并行解压与比对#

1
#!/bin/bash
2
# 并行解压 + 比对，避免磁盘 I/O 瓶颈
3

4
PIPE=$(mktemp -u)
5
mkfifo "${PIPE}"
6

7
# 后台：解压 FASTQ 到命名管道
8
gzip -dc sample.fastq.gz > "${PIPE}" &
9

10
# 前台：从管道读取并用 bwa 比对
11
bwa mem -t 16 /opt/refs/hg38.fa "${PIPE}" \
12
    | samtools sort -@ 8 -o aligned.sorted.bam -
13

14
rm "${PIPE}"
15

16
# 优势：解压和比对并行，避免把解压后的几十 GB 数据写入磁盘

对于磁盘 I/O 瓶颈的场景，命名管道能显著提速。时间模型：

$T_{pipe} = \max(T_{decompress}, T_{align})$

$T_{disk} = T_{decompress\_to\_disk} + T_{read\_from\_disk} + T_{align}$

当解压出的数据量很大时， $T_{pipe} \ll T_{disk}$ 。

6. xargs——跨越管道的限制#

管道的核心限制：每个 | 右边只能是一个命令的 stdin，不能是命令参数。xargs 就是打破这个限制的工具。

6.1 基础用法#

1
# 问题：管道只能传 stdin，不能传参数
2
# 下面的写法是错的：
3
echo "aligned.bam" | samtools view -h    # 错误！samtools view 需要参数不是 stdin
4

5
# 正确：用 xargs 把 stdin 变成参数
6
echo "aligned.bam" | xargs samtools view -h | head -20
7

8
# xargs 的核心：把 stdin 的每一行变成后面命令的参数

6.2 并行 xargs——生信批量处理加速#

1
# 对所有 BAM 文件并行生成索引（-P 指定并行数）
2
find . -name "*.bam" | xargs -P 8 -I {} samtools index {}
3

4
# -P 8  → 同时运行 8 个进程
5
# -I {} → {} 是占位符，代表每个输入行

对于独立任务（每个 BAM 文件互不影响），加速比近似为：

$S(n) = \frac{T_{serial}}{T_{parallel}} \approx \frac{n}{1 + \alpha(n - 1)}$

其中 $n$ 是并行数， $\alpha$ 是无法并行的比例（I/O 等待通常占 10-20%）。

6.3 生信批量处理模板#

1
# 1. 批量质控
2
ls *.fastq.gz | xargs -P 4 -I {} fastqc {} -o qc_results/
3

4
# 2. 批量比对
5
ls *_R1.fastq.gz | sed 's/_R1.fastq.gz//' | xargs -P 8 -I {} sh -c \
6
    'bwa mem -t 2 /opt/refs/hg38.fa {}_R1.fastq.gz {}_R2.fastq.gz | samtools sort -@ 2 -o aligned/{}_sorted.bam -'
7

8
# 3. 批量统计
9
ls *.bam | xargs -P 8 -I {} sh -c 'samtools flagstat {} > stats/{}.flagstat'

6.4 处理文件名中的空格#

1
# 文件名含空格时，用 -0 配合 find 的 -print0
2
find . -name "*.bam" -print0 | xargs -0 -P 4 -I {} samtools index {}
3

4
# -print0：用 \0 分隔（而不是换行）
5
# -0：xargs 以 \0 作为分隔符

7. 高级重定向技巧#

7.1 交换 stdout 和 stderr#

1
# 3>&2 2>&1 1>&3- 这个咒语的拆解
2
# 场景：想让 samtools 的日志走管道，但 BAM 数据写入文件
3

4
exec 3>&1                              # 备份原始 stdout 到 fd3
5
samtools view -bS aligned.sam 2>&1 1>&3 | tee samtools.log
6
exec 3>&-                              # 关闭 fd3
7

8
# 解释：2>&1 让 stderr 合并到当前的 stdout（此时是终端）
9
# 1>&3 让 stdout 恢复到原始的 fd3→终端
10
# 结果：stderr → 管道 → tee，stdout → 文件（通过重定向）

7.2 Here Documents——内嵌数据#

1
# 把多行文本直接传给命令
2
bcftools view -i 'QUAL>30' << 'EOF'
3
##fileformat=VCFv4.2
4
#CHROM  POS     ID      REF     ALT     QUAL    FILTER  INFO
5
chr1    12345   .       A       G       45.2    PASS    .
6
chr1    23456   .       C       T       12.1    PASS    .
7
EOF
8

9
# 在脚本里内嵌 GTF 注解的某几行
10
grep "BRCA1" << 'END_GTF' | cut -f1,4,5
11
chr17   41196312        41197819        BRCA1
12
chr17   41199659        41199719        BRCA1
13
END_GTF

7.3 Here Strings——单行快速输入#

1
# <<< 把字符串当 stdin
2
bcftools view -h variants.vcf.gz | grep "fileDate" <<< ""
3
# 或
4
grep "SRR12345678" <<< "$(cat sample_list.txt)"
5

6
# 用 bc 做简单计算
7
bc <<< "scale=4; 35000000 / 1000000"
8
# 输出：35.0000

8. 踩坑记录#

坑1：管道里的 set -e 不生效。 set -e 只看管道最后一个命令的退出码。如果 false | true，整个管道返回 0（因为 true 成功了）。解决方案：set -o pipefail 让任何一步失败都导致管道失败。

坑2：大管道缓冲溢出。 管道缓冲区默认 64KB（Linux），如果前一步输出快、后一步处理慢，超出缓冲区后前一步会阻塞。在 SAM→BAM 这种场景不明显，但在超大数据流（如全基因组测序 raw data）中可能成为瓶颈。可以用 pv 监控管道流量：cmd1 | pv | cmd2。

坑3：xargs 遇到空输入时默认仍执行命令。 echo "" | xargs rm 会执行 rm（无参数，可能报错）。用 xargs -r（--no-run-if-empty）防止空输入时执行。

坑4：命名管道没有读取端时写入端会阻塞。 mkfifo mypipe && gzip -c data > mypipe 如果没有另一个进程在读 mypipe，这个命令会永久挂起。务必先准备好读取端，或在写入端设置超时。

坑5：进程替换 <(...) 的退出码无法直接获取。 diff <(cmd1) <(cmd2) 中 cmd1 或 cmd2 失败了你不知道。Bash 4.4+ 可以用 wait 或临时文件来获取退出码。

坑6：2>&1 和 1>&2 的区别。 2>&1 是把 stderr 重定向到 stdout 当前指向的地方（注意”当前”两个字——在重定向链中顺序至关重要）。command 2>&1 > file 是错的：先把 stderr 指向当前 stdout（终端），再把 stdout 指向 file。正确是 command > file 2>&1。

坑7：xargs 中复合命令的引号嵌套地狱。 xargs -I {} sh -c 'command "{}"' 里引号嵌套很容易出错。改用 xargs -I {} bash -c "command '{}'" 或直接写成独立脚本。生信批量处理推荐写成独立脚本然后用 xargs 调用。

本文于 2025-11-22 在 Debian 12 上实测。