cat a.txt b.txt > merged.txt      # 这才是它的本职工作
cat part-*.csv > all.csv          # 拼接分片文件

cat -A config.txt
# name=value$              <- $ 是行尾（Unix 换行 LF）
# host=localhost^M$        <- ^M 是 \r，这是 Windows 换行 CRLF！
#                   ^^^^^^ 程序读到的 host 值是 "localhost\r"，连不上是必然的
# path=/data ^I$           <- ^I 是 tab，行尾还有个空格
#           ^^^ 尾随空白，很多配置解析器不会 trim

# 典型受害场景
# ① shell 脚本报 "$'\r': command not found"       -> CRLF
# ② 配置里的 IP 地址连不上                          -> 尾随 \r
# ③ YAML 缩进报错但肉眼看不出                      -> 混用 tab 和空格
# ④ 密码/token 认证失败                            -> 复制时带了尾随空格或换行

# 修复
dos2unix config.txt                    # 最直接（需安装 dos2unix）
sed -i 's/\r$//' config.txt            # 等价，无需额外安装
sed -i 's/[[:space:]]*$//' config.txt  # 去掉所有尾随空白

# ❌ 多起了一个进程，还多了一次管道拷贝
cat access.log | grep 500
cat access.log | wc -l

# ✅ 这些命令本来就接受文件名参数
grep 500 access.log
wc -l < access.log
#     ^ 用重定向也行，且 wc 不会输出文件名

# 什么时候 cat 是合理的？
cat a.log b.log | grep ERROR       # ✅ 真的要拼接多个文件
grep ERROR a.log b.log             # 也行，但输出会带文件名前缀

tac file                # cat 反过来拼（倒序输出行）—— 看日志最新的在前很有用
tac app.log | head -20  # 最后 20 行，且倒序显示

rev file                # 每行内部字符反转（不是行序）
echo "hello" | rev      # olleh
# 实用场景：按后缀排序（把域名反转后排序，能把同后缀的聚在一起）
cut -d: -f1 /etc/passwd | rev | sort | rev | head

nl file                 # 加行号（比 cat -n 更灵活）
nl -ba -w4 -s': ' file  # b=body 编号策略(a=所有行) w=宽度 s=分隔符

time less huge.log      # 瞬间打开，按 q 退出
# real  0m0.01s

# ① F 键：把 less 变成 tail -f，但可以随时 Ctrl-C 停下来往回翻
less app.log
# 按 F -> 开始实时跟随
# 看到可疑内容，按 Ctrl-C -> 停止跟随，此时可以自由搜索、往回翻
# 按 F -> 继续跟随
# 这比 tail -f 强太多：tail -f 里你没法往回看

less +F app.log         # 打开就直接进入跟随模式

# ② & 过滤：只显示匹配的行，其余隐藏
less app.log
# 输入 &ERROR 回车 -> 只剩含 ERROR 的行
# 输入 &!DEBUG 回车 -> 排除含 DEBUG 的行（! 表示取反）
# 输入 & 回车 -> 取消过滤
# 相当于在 less 内部做 grep，而且能随时改条件、不用退出重跑

# 推荐写进 ~/.bashrc 的默认值
export LESS='-R -i -M -S'
#             |  |  |  └ 长行不折行
#             |  |  └── 详细状态行（显示行号与百分比）
#             |  └───── 搜索忽略大小写
#             └──────── 保留颜色

# 各种实用组合
less -N +G app.log                    # 带行号，从末尾开始看
less -S data.csv                      # 宽表格不折行
journalctl -u nginx | less -R         # 保留 journalctl 的颜色
git log -p | less -R                  # git 默认就是用 less
docker logs -f app 2>&1 | less -R +F  # 跟随容器日志且可回翻

# lesspipe 让 less 能预处理各种格式（多数发行版默认已配好）
less app.log.gz            # 自动解压显示
less archive.tar.gz        # 显示包内文件列表
less image.png             # 显示图片元信息

# 没配好的话手动开
export LESSOPEN="| /usr/bin/lesspipe %s"
# 或者用专门的命令
zless app.log.gz

head file                 # 默认前 10 行
head -n 20 file           # 前 20 行（-n = --lines）
head -n -5 file           # 【除了最后 5 行】的所有内容（负数语义！）
head -c 100 file          # 前 100 字节（-c = --bytes）
head -c 1M bigfile        # 前 1MB
head -q a b               # quiet：多文件时不打印文件名头
head -v file              # verbose：单文件时也打印文件名头

tail file                 # 默认后 10 行
tail -n 50 file           # 后 50 行
tail -n +100 file         # 【从第 100 行开始】到结尾（+ 号语义！）
tail -c 1K file           # 后 1KB

# 组合技：取第 100~110 行
sed -n '100,110p' file            # ✅ 最直接
head -n 110 file | tail -n 11     # 也行
awk 'NR>=100 && NR<=110' file     # 也行

# 跳过 CSV 表头
tail -n +2 data.csv | wc -l

tail -f  app.log      # = --follow=descriptor（默认）：盯着这个 fd（也就是这个 inode）
tail -F  app.log      # = --follow=name --retry：盯着这个【路径】

# 亲手复现
echo "line1" > /tmp/t.log
tail -f /tmp/t.log &            # 后台跟随
mv /tmp/t.log /tmp/t.log.1      # 模拟轮转
echo "line2" > /tmp/t.log       # 写新文件
sleep 1
# tail -f 什么都没输出 —— 它还盯着老 inode

kill %1
tail -F /tmp/t.log &            # 换成 -F
echo "line3" >> /tmp/t.log
# line3   <- 正常输出
# tail: '/tmp/t.log' has been replaced;  following new file
#       ^^ -F 会检测到文件被替换并自动重新打开

tail -F -n 100 app.log            # 先显示最后 100 行，再开始跟随
tail -F app.log error.log         # 同时跟随多个文件（会打印 ==> 文件名 <== 分隔）
tail -F --pid=1234 app.log        # 进程 1234 结束时自动退出（脚本里很有用）
tail -F -s 5 app.log              # 每 5 秒检查一次（默认 1 秒），降低 IO
tail -f app.log --max-unchanged-stats=5   # 多少次无变化后重新检查文件名

# 直接跑：每来一行就显示（行缓冲）
tail -F app.log

# 接进管道：grep 要等上游攒够 4KB 才能收到数据（全缓冲）
tail -F app.log | grep ERROR
#                 ^^^^ 看起来"卡住了"，其实是在等 tail 的缓冲区填满
# 低频日志下可能几分钟才蹦出一批

# ① 用命令自带的行缓冲选项（最优先）
tail -F app.log | grep --line-buffered ERROR
#                      ^^^^^^^^^^^^^^^ grep 自己的输出也要行缓冲，否则它输出给下游时同样会攒
tail -F app.log | grep --line-buffered ERROR | awk '{print $1}'
#                 每一级都要处理，只要后面还有管道

awk '{print; fflush()}' file        # awk 用 fflush()
sed -u 's/a/b/' file                # sed 用 -u（--unbuffered）
python3 -u script.py                # python 用 -u
jq --unbuffered .                   # jq 用 --unbuffered

# ② 用 stdbuf 强制改变缓冲策略（对付没有相应选项的程序）
stdbuf -oL -eL mycommand | grep x
#       |   └ stderr 行缓冲
#       └──── stdout 行缓冲（L = line）
stdbuf -o0 mycommand | grep x       # 0 = 完全无缓冲（更慢但最实时）
# ⚠️ stdbuf 通过 LD_PRELOAD 注入，只对使用 stdio 的动态链接程序有效，
#    对静态链接的 Go 程序无效（Go 不用 stdio）

# ③ 用伪终端骗过程序（终极手段）
unbuffer mycommand | grep x         # 需要 expect 包
script -qfc "mycommand" /dev/null | grep x
# 原理：创建一个伪终端（pty），让程序以为自己连着终端，于是选择行缓冲

// os.Stdout 是【无缓冲】的：每次 Write 都是一次 syscall
fmt.Println("立即输出")          // 直接 write(1, ...)，管道里也能马上被下游看到

// 但如果你自己套了 bufio（为了性能），就有缓冲了
w := bufio.NewWriter(os.Stdout)
fmt.Fprintln(w, "这行会被缓冲")
// 不 Flush 的话下游收不到
w.Flush()                        // ✅ 必须显式刷
defer w.Flush()                  // 或者 defer（注意 panic 时不一定执行）

// 日志库同理：检查你的 logger 是否带缓冲
// zap 的 SugaredLogger 需要 defer logger.Sync()
defer logger.Sync()

# 看进程实际的 write 系统调用频率
strace -f -e trace=write -p $(pidof myapp) 2>&1 | head -20
# 如果一批日志攒到一起才 write 一次，说明有缓冲

file -i mystery.txt
# mystery.txt: text/plain; charset=utf-8
file --mime-encoding mystery.txt
# utf-8

# 常见结果与含义
# charset=us-ascii      纯 ASCII，任何编码都能正确显示
# charset=utf-8         UTF-8
# charset=iso-8859-1    file 分不出来时的兜底猜测，中文文件多半其实是 GBK
# charset=binary        不是文本文件

# ⚠️ file 的编码判断是【启发式】的，短文本、中文文件经常判错。
#    更准的工具：
enca -L zh_CN mystery.txt              # 专门做编码检测（需装 enca）
python3 -c "import chardet,sys; print(chardet.detect(open(sys.argv[1],'rb').read()))" f
# {'encoding': 'GB2312', 'confidence': 0.99}

# 最实用的办法：直接试着转，看哪个不报错、内容通顺
iconv -f gbk   -t utf-8 mystery.txt | head
iconv -f big5  -t utf-8 mystery.txt | head

iconv -f gbk -t utf-8 old.txt > new.txt
#      ^^^^^ from      ^^^^^^ to

# 遇到无法转换的字符时的三种策略
iconv -f gbk -t utf-8 f            # 默认：遇到非法字节直接报错中止
iconv -f gbk -t utf-8//IGNORE f    # 忽略无法转换的字符（继续处理）
iconv -f gbk -t utf-8//TRANSLIT f  # 音译近似字符（如 é -> e）

iconv -l | head                    # 列出支持的所有编码（有上千种）
iconv -l | grep -i gb              # 找中文相关的：GBK GB2312 GB18030

# 批量转换整个目录
find . -name '*.txt' -exec sh -c 'iconv -f gbk -t utf-8 "$1" -o "$1.tmp" && mv "$1.tmp" "$1"' _ {} \;

# ⚠️ 不能原地转换！这会清空文件
iconv -f gbk -t utf-8 f > f        # 💀 重定向先把 f 截断成 0 字节了
iconv -f gbk -t utf-8 f -o f       # ✅ 用 -o（较新版本支持）
iconv -f gbk -t utf-8 f > f.tmp && mv f.tmp f    # ✅ 或者用临时文件

# ① BOM（字节序标记）：UTF-8 文件开头的 EF BB BF
head -c 3 script.sh | xxd
# 00000000: efbb bf                  ...
#           ^^^^^^^^ 有 BOM

# 后果：shebang 前面多了 3 个字节，内核识别不出 #!，脚本无法执行
./script.sh
# bash: ./script.sh: cannot execute: required file not found
#  或   -bash: ./script.sh: /bin/bash^M: bad interpreter

# 去掉 BOM
sed -i '1s/^\xEF\xBB\xBF//' script.sh
dos2unix script.sh                       # dos2unix 也会顺带去 BOM

# ② CRLF：Windows 的换行是 \r\n，Unix 是 \n
file script.sh
# script.sh: Bourne-Again shell script, ASCII text executable, with CRLF line terminators
#                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ 

./script.sh
# bash: ./script.sh: /bin/bash^M: bad interpreter: No such file or directory
#                             ^^ 解释器路径变成了 "/bin/bash\r"

# 修复
dos2unix script.sh
sed -i 's/\r$//' script.sh
tr -d '\r' < win.txt > unix.txt

# 反向转换（给 Windows 用）
unix2dos file
sed -i 's/$/\r/' file

# 预防：git 层面统一
git config --global core.autocrlf input     # Linux/macOS 推荐：提交时转 LF，检出不转
# 或在仓库根放 .gitattributes
echo '* text=auto eol=lf' > .gitattributes
echo '*.sh text eol=lf' >> .gitattributes

cat /bin/ls          # 💀 终端开始输出方块、乱码，之后敲什么都不对

# 恢复方法（按推荐顺序，即使看不见自己输入的字也要照敲）
reset                # 完全重置终端（最彻底，会清屏）
tput reset           # 同上
stty sane            # 恢复终端行设置（回显、换行等），不清屏
# 如果连回车都不响应，先按 Ctrl-J（真正的换行符）再敲命令
# 终极方案：关掉这个终端标签重开；ssh 的话按 Enter ~ . 强制断开

file unknown_file            # 先看是什么
head -c 100 unknown_file | xxd    # 只看前 100 字节的十六进制，绝对安全
less unknown_file            # less 会把控制字符转义显示，不会搞乱终端
strings unknown_file | head  # 只抽取可打印字符串

grep "error" /bin/ls
# Binary file /bin/ls matches
#  ^^ grep 检测到文件含 NUL 字节，判定为二进制，为了保护终端只报告"匹配了"而不输出内容

grep -a "error" /bin/ls      # -a = --text，强制当文本处理并输出内容
grep -a "error" core.1234 | head

xxd file | head -3
# 00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............
# ^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^
# 偏移量     十六进制内容（每 2 字节一组）              ASCII 显示（不可打印显示为 .）
#           ^^^^^^^^^ 7f 45 4c 46 = \x7f ELF，这就是 ELF 可执行文件的魔数

xxd -l 16 /bin/ls                    # 只看文件头，判断类型
xxd -s 1024 -l 64 disk.img           # 从 1024 字节处开始看 64 字节
xxd -g 1 -c 8 file                   # 单字节分组、每行 8 个，最易读
xxd -p file                          # 纯 hex，方便复制

# 改二进制文件的经典流程（hex 编辑）
xxd file > file.hex                  # 转成文本
vim file.hex                         # 编辑（只改中间的 hex 列，别动偏移和 ASCII）
xxd -r file.hex > file.new           # 转回二进制

# 判断真实文件类型（比扩展名可靠）
xxd -l 8 unknown | head -1
# 7f45 4c46 -> ELF 可执行文件
# 504b 0304 -> ZIP（也是 docx/xlsx/jar/apk）
# 8950 4e47 -> PNG
# ffd8 ffe0 -> JPEG
# 1f8b      -> gzip
# 2321      -> #! 脚本

od -A x -t x1z -v file | head        # od = octal dump（更老，参数晦涩）
#  ^^^^ 地址用十六进制 ^^^^^^ 单字节 hex + ASCII  ^^ 不压缩重复行
hexdump -C file | head               # -C = canonical，输出格式与 xxd 类似

strings binary | head
# 抽取所有【连续 4 个及以上可打印字符】的序列

# 实战场景
strings myapp | grep -i 'password\|secret\|token'    # 检查有没有硬编码密钥 ← 安全审计
strings core.1234 | grep -i 'panic\|error' | head     # 从 core dump 里找线索
strings -t x binary | grep 'v1.2.3'                   # 找版本号及其偏移
strings /proc/1234/environ                            # 看进程环境变量（也可直接 tr）
strings -n 8 unknown.bin | head -50                   # 判断未知文件的内容线索

# Go 二进制专用（比 strings 强得多）
go version -m ./myapp
# ./myapp: go1.22.0
#     path    github.com/me/myapp
#     mod     github.com/me/myapp  (devel)
#     dep     github.com/gin-gonic/gin  v1.9.1  h1:...
#     build   -ldflags="-s -w"
#     build   CGO_ENABLED=0
#     build   vcs.revision=abc123def
#  ^^ 完整的依赖清单与构建参数，排查线上二进制版本时极其有用

file myapp                       # 静态还是动态链接
ldd myapp                        # 依赖哪些动态库（静态链接会显示 "not a dynamic executable"）
# ⚠️ 不要对不可信的二进制跑 ldd —— 它某些实现会实际运行程序
objdump -p myapp | grep NEEDED   # ✅ 更安全的替代
readelf -d myapp | grep NEEDED

nm -D myapp | head               # 动态符号表
readelf -h myapp                 # ELF 头（架构、类型、入口地址）
objdump -d myapp | head -40      # 反汇编

wc file
#   120   890  7654 file
#    ^^^   ^^^  ^^^^ 字节数
#    |     单词数
#    行数

wc -l < file                     # ✅ 用重定向，输出里不带文件名，方便脚本取值
wc -l file                       # 输出 "120 file"，脚本里要再切一次
find . -name '*.go' | wc -l      # 数文件个数
wc -lc 中文.txt                  # 对比字节数与字符数
wc -L file                       # 查最长行（找异常的超长日志行）

# ⚠️ wc -l 数的是【换行符个数】，最后一行没有换行时会少算一行
printf 'a\nb' | wc -l            # 1   （实际有两行内容！）
printf 'a\nb\n' | wc -l          # 2
grep -c '' file                  # ✅ 更准确的行数统计
awk 'END{print NR}' file         # ✅ 同样准确

md5sum file                      # 快，但已不安全（可构造碰撞），只用于校验传输完整性
sha256sum file                   # 推荐
sha1sum / sha512sum / b2sum      # 其他算法
cksum file                       # CRC32（很快，防传输错误够用）

# 校验下载文件
sha256sum -c SHA256SUMS          # 用清单文件批量校验
echo "abc123...  go1.22.tar.gz" | sha256sum -c -
# go1.22.tar.gz: OK

# 生成清单
sha256sum *.tar.gz > SHA256SUMS

# 比较两个文件是否相同（大文件时比 diff 快）
[[ $(md5sum < a) == $(md5sum < b) ]] && echo same
cmp -s a b && echo same          # ✅ 更快：逐字节比，发现不同立即停止

cmp a b                          # 报告第一处不同的字节位置与行号
# a b differ: byte 15, line 2
cmp -s a b; echo $?              # -s 静默，只看退出码（0=相同 1=不同 2=出错）
cmp -l a b                       # 列出所有不同的字节（八进制）

diff a b                         # 默认格式（老式）
diff -u a b                      # ✅ unified 格式，就是 git diff 的样子，最易读
diff -u --color=always a b | less -R
diff -r dir1 dir2                # 递归比较目录
diff -q -r dir1 dir2             # 只报告哪些文件不同，不显示内容
diff -y a b                      # 并排显示（side by side）
diff -w a b                      # 忽略空白差异
diff -B a b                      # 忽略空行
diff -i a b                      # 忽略大小写

# 生成与应用补丁
diff -u old.c new.c > fix.patch
patch old.c < fix.patch          # 应用
patch -R old.c < fix.patch       # 撤销

# 更好用的现代工具
git diff --no-index a b          # 用 git 的 diff 引擎（有颜色、有词级高亮）
delta / difftastic               # 第三方，语法感知的 diff
vimdiff a b                      # 在 vim 里并排比较（第 06 篇讲）

# comm：比较两个【已排序】文件的行
comm -12 <(sort a) <(sort b)     # 只显示两者都有的行（交集）
comm -23 <(sort a) <(sort b)     # 只在 a 里有的（差集）
comm -3  <(sort a) <(sort b)     # 只显示不同的
#      ^^ 数字表示"抑制第几列"：1=只在a  2=只在b  3=共有

zcat  app.log.gz                 # = gunzip -c，输出到 stdout
zless app.log.gz                 # 用 less 浏览
zgrep ERROR app.log.gz           # 直接在压缩文件里搜
zdiff a.gz b.gz                  # 比较两个压缩文件
zcat *.gz | grep ERROR           # 搜所有归档

bzcat / bzless / bzgrep          # bzip2
xzcat / xzless / xzgrep          # xz
zstdcat / zstdgrep               # zstd（现在最快的通用压缩，推荐）

tar -tzvf archive.tar.gz         # 只看归档内的文件列表（不解压）
tar -xzOf archive.tar.gz path/to/file    # 只把某一个文件解到 stdout
#       ^ O = --to-stdout

# ① 实时跟随并高亮（不过滤，只是标红）
tail -F app.log | grep --line-buffered --color=always -E 'ERROR|WARN|$'
#                                                        ^^^^^^^^^^^^^^ 加 |$ 匹配所有行，
#                                                        效果是"全部显示但关键词标红"

# ② 实时跟随并过滤（注意行缓冲）
tail -F app.log | grep --line-buffered -i 'timeout\|refused'

# ③ 按时间段截取（日志时间戳格式为 2026-08-12 21:30:00）
awk '$0 >= "2026-08-12 21:00" && $0 <= "2026-08-12 22:00"' app.log
sed -n '/2026-08-12 21:00/,/2026-08-12 22:00/p' app.log

# ④ 统计 top N（第 08 篇会细讲 awk）
awk '{print $NF}' access.log | sort | uniq -c | sort -rn | head -10
grep -oP 'status=\K\d+' app.log | sort | uniq -c | sort -rn

# ⑤ 看错误的上下文
grep -n -B5 -A10 'panic' app.log | less -R
#        ^^^ 前 5 行  ^^^ 后 10 行

# ⑥ 多文件同时跟随并标注来源
tail -F app.log error.log access.log        # 自带 ==> 文件名 <== 分隔
# 更好的工具：multitail、lnav（专业日志浏览器，自动识别格式、支持 SQL 查询）

# ⑦ 大文件里定位到具体位置后从那开始看
grep -n 'panic' huge.log | head -1          # 找到行号，比如 458392
less +458392g huge.log                      # 直接跳过去
sed -n '458380,458420p' huge.log            # 或者直接截取那一段

# ⑧ systemd 服务的等价操作（推荐，没有轮转问题）
journalctl -fu myapp                        # 跟随
journalctl -u myapp --since '1 hour ago'    # 时间范围
journalctl -u myapp -p err                  # 只看 error 及以上级别
journalctl -u myapp -o json-pretty | less   # 结构化输出
journalctl -u myapp --since today | grep -i timeout

export LESS='-R -i -M -S'          # 默认参数
export LESSHISTFILE=-              # 不保存搜索历史（默认存 ~/.lesshst）
export PAGER=less                  # 给其他程序用的默认分页器
export MANPAGER='less -R'          # man 专用
export LESSOPEN="| lesspipe %s"    # 预处理器（自动解压、看归档）

wc -l < f                        # 行数（脚本用重定向）
grep -c '' f                     # 更准确的行数（文件末尾无换行时）
cmp -s a b && echo same          # 快速判断是否相同
diff -u a b                      # 可读的差异
diff -qr d1 d2                   # 目录差异摘要
sha256sum -c SHA256SUMS          # 批量校验
comm -12 <(sort a) <(sort b)     # 交集

reset                # 完全重置（清屏 + 恢复所有设置）
tput reset           # 同上
stty sane            # 恢复终端行设置，不清屏
stty -a              # 查看当前终端设置
clear                # 只清屏（Ctrl-L）
Ctrl-J               # 终端不响应回车时，用它代替（真正的 \n）
Enter ~ .            # ssh 会话卡死时强制断开（依次按这三个键）