# ① 内核版本（Linux 本身的版本）
uname -r
# 5.15.0-91-generic

# ② 完整内核信息
uname -a
# Linux prod-web-01 5.15.0-91-generic #101-Ubuntu SMP Tue Nov 14 13:30:08 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux
# ^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^
# 内核名  主机名       内核版本-发行版补丁号   编译时间                            架构

# ③ 发行版（这才是决定"用 apt 还是 dnf"的东西）
cat /etc/os-release
# PRETTY_NAME="Ubuntu 22.04.3 LTS"
# NAME="Ubuntu"
# VERSION_ID="22.04"
# ID=ubuntu
# ID_LIKE=debian              <- 关键：告诉你它属于哪个家族
# VERSION_CODENAME=jammy

# ④ 架构（决定下载哪个二进制包、Go 交叉编译的 GOARCH）
uname -m
# x86_64          <- 对应 Go 的 GOARCH=amd64
# aarch64         <- 对应 Go 的 GOARCH=arm64（云上 ARM 机型越来越多）

# ⑤ 一条命令看全（systemd 系统上）
hostnamectl
#  Static hostname: prod-web-01
#        Icon name: computer-vm
#          Chassis: vm                          <- 是虚拟机还是物理机
# Operating System: Ubuntu 22.04.3 LTS
#           Kernel: Linux 5.15.0-91-generic
#     Architecture: x86-64

. /etc/os-release           # 它就是一个 shell 变量赋值文件，可以直接 source
echo "$ID / $ID_LIKE / $VERSION_ID"
# ubuntu / debian / 22.04

case "$ID_LIKE $ID" in
  *debian*) PKG="apt-get install -y" ;;
  *rhel*|*fedora*) PKG="dnf install -y" ;;
  *alpine*) PKG="apk add" ;;
  *) echo "unknown distro"; exit 1 ;;
esac

uname -r
# 5.15.0-91-generic
# │ │  │  │  └──────── 发行版自己的风味标记（generic/aws/azure/cloud）
# │ │  │  └─────────── 发行版的补丁号（Ubuntu 打了 91 次补丁）
# │ │  └────────────── 修订号（上游稳定版补丁）
# │ └───────────────── 主版本内的次版本
# └─────────────────── 主版本

# 查内核编译时开启了哪些特性（排查 cgroup v2、eBPF 支持时常用）
grep -E 'CONFIG_CGROUP_BPF|CONFIG_BPF_SYSCALL' /boot/config-$(uname -r)
# CONFIG_BPF_SYSCALL=y
# CONFIG_CGROUP_BPF=y

# 或者从 /proc 看运行时能力
cat /sys/fs/cgroup/cgroup.controllers 2>/dev/null && echo "cgroup v2"

# 查自己的版本还有多久到期（Ubuntu）
ubuntu-support-status 2>/dev/null || cat /etc/os-release | grep VERSION
# RHEL 系看 https://access.redhat.com/support/policy/updates/errata

# 如果你在 CentOS 7/8 上，迁移路径通常是
# CentOS 7 -> Rocky/Alma 8 或 9（rpm 生态不变，迁移成本低）
# CentOS 7 -> Ubuntu LTS（生态换家族，成本高但社区资源最多）

# Rocky/Alma 提供了原地转换脚本
# migrate2rocky.sh / almalinux-deploy.sh

# 现象一：在 Ubuntu 上编译的 Go 二进制，放进 Alpine 容器跑不起来
./myapp
# sh: ./myapp: not found
#     ^^^^^^^^^ 文件明明在！这个报错极具误导性

# 真正的原因：二进制动态链接了 glibc，而 Alpine 里没有 glibc
file myapp
# ELF 64-bit LSB executable, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2
#                            ^^^^^^^^^^^^^^^^^^ 需要动态链接器
ldd myapp
# linux-vdso.so.1
# libc.so.6 => not found        <- 找不到 glibc，所以内核加载失败，shell 报 "not found"

# ✅ 解法：关掉 CGO，让 Go 静态编译
CGO_ENABLED=0 go build -o myapp .
file myapp
# ELF 64-bit LSB executable, statically linked        <- 不依赖任何 libc，任何镜像都能跑

# 现象二：Alpine 容器里 Go 服务解析内网域名失败，Ubuntu 容器里正常
# 原因：纯 Go resolver 只读 /etc/resolv.conf 和 /etc/hosts，
#      不走 NSS，所以某些依赖 NSS 模块的解析方式会失效。
# 还有一个历史坑：musl 的 DNS 实现不支持 search domain 的某些边界情况，
#      且早期版本对 TCP 回退（超过 512 字节的响应）处理不同。

# 排查时先确认用的是哪个 resolver
go env CGO_ENABLED
# 0        <- 纯 Go resolver

# 也可以在运行时强制指定
GODEBUG=netdns=go   ./myapp      # 强制纯 Go
GODEBUG=netdns=cgo  ./myapp      # 强制走 libc
GODEBUG=netdns=2    ./myapp      # 打印它到底选了哪个（排查神器）

# 生产环境的标准两阶段构建
FROM golang:1.22 AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /app ./cmd/server

FROM gcr.io/distroless/static-debian12
COPY --from=builder /app /app
# 注意：scratch/distroless 里没有 shell，kubectl exec 进不去，
#       排查要靠 ephemeral container（kubectl debug）或日志
USER nonroot:nonroot
ENTRYPOINT ["/app"]

type -a ls
# ls is aliased to `ls --color=auto'          <- ① 别名
# ls is /usr/bin/ls                           <- ④ 外部程序

type -a cd
# cd is a shell builtin                       <- ③ 内建命令，不是文件！

type -a if
# if is a shell keyword                       <- ⑤ 关键字

type -a ll
# ll is aliased to `ls -alF'

type -a time
# time is a shell keyword
# time is /usr/bin/time                       <- 同名的关键字和程序共存，行为不同！

# ① 别名优先级最高，所以别名能"覆盖"真命令
alias ls='ls --color=auto'
ls              # 实际执行的是 ls --color=auto

# 想临时绕过别名，三种方式
\ls             # 反斜杠转义
command ls      # command 跳过别名和函数，但仍走 builtin 和 PATH
/usr/bin/ls     # 直接写绝对路径

# ② 函数能覆盖外部命令 —— 这是排查诡异行为时容易忽略的一层
grep() { echo "被劫持了"; }
grep foo file   # 被劫持了
unset -f grep   # 取消函数定义

# ③ builtin 优先于 PATH，所以 /usr/bin/echo 平时用不到
type -a echo
# echo is a shell builtin
# echo is /usr/bin/echo        <- 存在但轮不到它
builtin echo hi                # 强制用 builtin
/usr/bin/echo hi               # 强制用外部程序（两者对 -e 等参数的处理略有差异）

# 每个进程都有自己的 cwd，可以直接看
ls -l /proc/self/cwd
# lrwxrwxrwx 1 lhx lhx 0 Aug 12 22:00 /proc/self/cwd -> /home/lhx

# 两个 shell 的 cwd 互不影响
ls -l /proc/$$/cwd       # $$ 是当前 shell 的 PID

# script.sh 内容：export FOO=bar; cd /tmp

./script.sh           # 起子进程执行 -> 子进程里 FOO 和 cwd 都变了，退出后全没了
echo $FOO; pwd        # 空 / /home/lhx

source script.sh      # 在当前 shell 里执行 -> 真的改了当前 shell
echo $FOO; pwd        # bar / /tmp

time for i in {1..10000}; do echo x >/dev/null; done
# real  0m0.09s          <- builtin

time for i in {1..10000}; do /usr/bin/echo x >/dev/null; done
# real  0m5.20s          <- 每次都 fork + exec，慢 50 倍

which cd
# （什么都没输出，退出码非 0）
#  ^^ which 是【外部程序】，它只扫 PATH，根本不知道 builtin、alias、function 的存在

which ls
# /usr/bin/ls
#  ^^ 也没告诉你其实有个 alias 会先生效

# ✅ 正确的工具
type -a ls           # 显示所有身份（alias/builtin/function/文件），bash 内建
command -v ls        # POSIX 标准，脚本里判断"命令是否存在"用这个
command -V ls        # 更详细的描述（类似 type）

# ✅ 推荐（POSIX，任何 shell 都支持）
if command -v jq >/dev/null 2>&1; then
    echo "jq 已安装"
fi

# ❌ 不推荐
if which jq >/dev/null; then ...        # which 在某些系统上即使找不到也返回 0
if type jq >/dev/null; then ...         # type 在 dash 等非 bash shell 里行为不一致

whereis ls           # /usr/bin/ls /usr/share/man/man1/ls.1.gz
#                      ^^ 同时找【程序、源码、man 手册】，按固定目录列表搜索，不看 PATH
whatis ls            # ls (1) - list directory contents        <- 一句话说明它是干什么的
apropos "list dir"   # 按关键词【搜索】所有 man 页面（不知道命令名时用）

hash                 # 查看缓存表
# hits	command
#    5	/usr/bin/git
#    2	/usr/local/go/bin/go

# 典型故障：把 go 从 /usr/local/go 换到 /opt/go，PATH 也改了，但仍执行旧路径
go version
# bash: /usr/local/go/bin/go: No such file or directory
#       ^^^^^^^^^^^^^^^^^^^^ 缓存里还是旧路径

hash -r              # 清空整张缓存表  ← 记住这个
hash -d go           # 只删 go 这一条
hash -t go           # 查 go 缓存的是哪个路径

echo $PATH
# /home/lhx/.local/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
#  ^^^^^^^^^^^^^^^^^^^ 从左到右依次查找，【第一个匹配就用】，找到即停

# 更易读的展示
tr ':' '\n' <<< "$PATH"

ls -ld /bin /sbin /lib
# lrwxrwxrwx 1 root root 7 Apr 22 2023 /bin -> usr/bin       <- 就是个软链接
# lrwxrwxrwx 1 root root 8 Apr 22 2023 /sbin -> usr/sbin

# 临时（只影响当前 shell）
export PATH="$PATH:/usr/local/go/bin"        # 追加到末尾
export PATH="/opt/mytool/bin:$PATH"          # 插到最前（优先级最高）
#             ^^^^^^^^^^^^^^^^ 想覆盖系统同名命令时放前面

# ⚠️ 一定要保留原来的 $PATH，否则整个 shell 就废了
export PATH="/usr/local/go/bin"               # ❌ 现在 ls、cat 全都 command not found
# 救急：用绝对路径修回来
export PATH="/usr/bin:/bin:/usr/sbin:/sbin"

# 永久：写进配置文件（哪个文件见下）
echo 'export PATH="$PATH:/usr/local/go/bin"' >> ~/.bashrc
source ~/.bashrc

export PATH=".:$PATH"        # 💀 极危险
# 攻击场景：攻击者在 /tmp 放一个名叫 ls 的恶意脚本，
#          你 cd /tmp 然后敲 ls，执行的就是他的脚本（以你的权限）
# 这也是为什么执行当前目录的程序必须写 ./myapp 而不是 myapp

go version
# go version go1.22.0 linux/amd64

sudo go version
# sudo: go: command not found

sudo grep secure_path /etc/sudoers
# Defaults	secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
#                        ^^ 里面没有 /usr/local/go/bin，所以找不到 go

# 设计动机：防止普通用户通过篡改自己的 PATH，让 sudo 执行一个伪造的同名程序提权

# 三种解法
sudo /usr/local/go/bin/go version        # ① 写绝对路径（最推荐）
sudo env "PATH=$PATH" go version         # ② 显式把 PATH 带过去
sudo -E go version                       # ③ 保留全部环境变量（需 sudoers 允许，权限较松）

# ④ 或者把路径加进 secure_path（用 visudo 改，别直接编辑 /etc/sudoers）
sudo visudo
# Defaults	secure_path="...:/usr/local/go/bin"

FOO=bar                  # shell 变量：只在当前 shell 里可见
export FOO=bar           # 环境变量：会被【子进程继承】
export -n FOO            # 降级成普通 shell 变量（取消导出，但保留值）
unset FOO                # 彻底删除

# 验证继承关系
FOO=local
export BAR=exported
bash -c 'echo "FOO=[$FOO] BAR=[$BAR]"'
# FOO=[] BAR=[exported]        <- 只有 export 过的能传给子进程

# 三个查看命令的区别
env                      # 只列【环境变量】（外部程序，看到的是它自己继承到的那份）
printenv FOO             # 打印单个环境变量（比 echo $FOO 更严格：只认环境变量）
set                      # 列出【所有】shell 变量 + 函数（内建命令，输出巨长）
declare -p FOO           # 看变量的类型与属性（-x 表示已导出）

# 只给一条命令临时设置环境变量（不影响当前 shell）
GOOS=linux GOARCH=arm64 go build ./...
#^^^^^^^^^^^^^^^^^^^^^^ 前置赋值，只对这一条命令生效  ← Go 交叉编译常用

# 看一个【正在运行的进程】的环境变量（排查配置没生效的神器）
sudo tr '\0' '\n' < /proc/1234/environ
#         ^^^^ environ 里各变量用 \0 分隔，要转成换行才能读

go env                       # 看 Go 的全部环境（GOROOT/GOPATH/GOPROXY/GOCACHE...）
go env GOPATH GOPROXY        # 只看指定项
go env -w GOPROXY=https://goproxy.cn,direct    # 持久化写入（存到 ~/.config/go/env）
#      ^^ 注意：go env -w 写的是 Go 自己的配置文件，不是 shell 环境变量

# GOROOT vs GOPATH（新手最容易混）
# GOROOT = Go 工具链自己的安装目录（/usr/local/go），一般不用手动设
# GOPATH = 你的工作区（默认 ~/go），go install 的二进制放在 $GOPATH/bin
export PATH="$PATH:$(go env GOPATH)/bin"       # 这样 go install 装的工具才能直接用

cat ~/.bash_profile
# if [ -f ~/.bashrc ]; then . ~/.bashrc; fi
#                            ^^^^^^^^^^^ 关键的一行，Ubuntu 的 ~/.profile 默认就有

# 判断当前 shell 是哪种
shopt -q login_shell && echo "登录 shell" || echo "非登录 shell"
echo $-        # 输出里含 i 表示交互式（himBHs 里的 i）

# 本地手动跑没问题
go version                        # ok

# 但 CI 里 / ssh 远程执行 / cron 里报 command not found
ssh host 'go version'
# bash: go: command not found
#  ^^ 非交互式 shell 不读 .bashrc，所以你加的 PATH 不生效

# 解法：显式写绝对路径，或在脚本里自己 source
ssh host 'export PATH=$PATH:/usr/local/go/bin; go version'
ssh host 'bash -lc "go version"'    # -l 让它当登录 shell 跑，会读 profile

ls --help | head -20     # 参数清单，速查用
man ls                   # 完整手册：设计意图、环境变量、退出码、示例、相关命令

# 在 --help 输出里直接搜参数（最高频的动作）
ls --help | grep -- '-S'
#                ^^ -- 表示后面的 -S 是搜索内容而不是 grep 的选项
#   -S                         sort by file size, largest first

tar --help | grep -A2 'exclude'
#                  ^^^^ 顺带显示后 2 行上下文

# busybox / alpine 环境里没有 man，只能靠 --help
busybox ls --help

man 1 write        # write 命令：给别的登录用户发消息
man 2 write        # write() 系统调用：往 fd 写数据      ← 写 Go/C 时查这个
man 3 printf       # printf() C 库函数：格式化输出
man 1 printf       # printf 命令：shell 里的格式化输出
man 5 crontab      # crontab 文件的格式（五个时间字段怎么写）
man 1 crontab      # crontab 命令（-e -l -r 怎么用）      ← 两个都要看

# 不指定章节时，man 按 1→8 的顺序返回【第一个】找到的
man write          # 得到的是 write(1)，不是你想要的系统调用！

# 看某个名字在哪些章节都有
man -f write       # 等价 whatis
# write (1)            - send a message to another user
# write (2)            - write to a file descriptor
# write (1posix)       - write to another user

man -a write       # 依次显示所有章节（看完一个按 q 进下一个）

# 例：查 write() 的返回值语义（Go 里 Write 返回 n < len(p) 的原因就在这）
man 2 write
# RETURN VALUE
#   On success, the number of bytes written is returned.  ... it is not an error
#   if this number is smaller than the number of bytes requested
#   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 部分写入不是错误！

# 例：查 signal 的完整列表与默认行为
man 7 signal | grep -A3 SIGTERM

# 例：读懂 ln 的 SYNOPSIS 就知道它有四种用法
man ln | sed -n '/SYNOPSIS/,/DESCRIPTION/p'
# SYNOPSIS
#      ln [OPTION]... [-T] TARGET LINK_NAME
#      ln [OPTION]... TARGET                  <- 只给目标，在当前目录创建同名链接
#      ln [OPTION]... TARGET... DIRECTORY     <- 多个目标放进一个目录
#      ln [OPTION]... -t DIRECTORY TARGET...  <- 目录在前的写法

man ls
# 然后：
#   /关键词      向下搜索（回车确认）
#   ?关键词      向上搜索
#   n / N       跳到下一个 / 上一个匹配
#   空格 / b     下一页 / 上一页
#   g / G       跳到开头 / 结尾
#   q           退出
#   h           看 less 自己的帮助

# 精确定位某个参数的说明（最高频技巧）
#   在 man 里输入： /^\s*-S
#                  ^^^^^ 行首若干空白后紧跟 -S，能直接跳到该参数的解释
#   查长参数：      /--reflink

# 直接在命令行里抽取想看的段落
man ls | sed -n '/^SYNOPSIS/,/^DESCRIPTION/p'      # 只看 SYNOPSIS
man tar | sed -n '/^EXAMPLES/,/^SEE ALSO/p'        # 只看示例
man ssh | grep -n 'ProxyJump'                      # 找关键词在第几行

# 把 man 转成纯文本存下来慢慢看
man -P cat ls > ls.txt          # -P 指定分页器为 cat（直接输出）
man ls | col -b > ls.txt        # col -b 去掉退格控制符

# 生成 PDF（需要 groff）
man -t ls | ps2pdf - ls.pdf

apropos "disk usage"
# du (1)               - estimate file space usage
# df (1)               - report file system disk space usage
#  ^^ 按关键词搜索所有 man 页的 NAME 段

man -k compress        # 等价于 apropos
# gzip (1)             - compress or expand files
# zstd (1)             - zstd, zstdmt, unzstd, zstdcat - Compress or decompress
# xz (1)               - Compress or decompress .xz and .lzma files

apropos -s 2 socket    # 只在章节 2（系统调用）里搜
# socket (2)           - create an endpoint for communication
# socketpair (2)       - create a pair of connected sockets

# ⚠️ apropos 依赖手册索引数据库，新装的软件可能搜不到
sudo mandb             # 重建索引（Debian 系）
sudo makewhatis        # RHEL 系

# ① info：GNU 工具的完整文档，通常比 man 详细得多
info coreutils 'ls invocation'      # ls 的完整文档，比 man ls 长
info bash                            # bash 的完整手册（man bash 也有，但 info 有目录导航）
# 导航：n 下一节  p 上一节  u 上一层  Enter 进入链接  q 退出
# GNU 的官方立场是"man 只是简介，info 才是完整文档"

# ② /usr/share/doc/<包名>/：官方 README、示例配置、变更日志
ls /usr/share/doc/openssh-server/
# README.Debian  changelog.Debian.gz  examples/
zcat /usr/share/doc/curl/NEWS.gz | head       # 看版本变更

# ③ tldr：社区维护的「只给例子」速查（需要安装）
sudo apt install tldr && tldr tar
# - Create an archive from files:
#     tar cf target.tar file1 file2
# - Extract an archive in a target directory:
#     tar xf source.tar -C directory
#  ^^ 只有最常用的 5~8 个例子，学新命令时比 man 快得多

# 相关工具：cheat、navi、eg

# 第 1 步：确认它是什么（10 秒）
type -a tar; whatis tar
# tar is /usr/bin/tar
# tar (1) - an archiving utility

# 第 2 步：看 SYNOPSIS，搞清骨架（20 秒）
man tar | sed -n '/^SYNOPSIS/,/^DESCRIPTION/p'
# tar [OPTION...] [FILE]...
# 看不出太多信息 -> 说明这个命令的参数是"模式 + 修饰"结构，继续看

# 第 3 步：找出核心的"操作模式"（40 秒）
tar --help | grep -A12 'Main operation mode'
#  -A, --catenate, --concatenate   append tar files to an archive
#  -c, --create                    create a new archive          <- 打包
#  -d, --diff, --compare           find differences
#      --delete                    delete from the archive
#  -r, --append                    append files to the end
#  -t, --list                      list the contents             <- 查看
#  -u, --update                    only append newer
#  -x, --extract, --get            extract files                 <- 解包
# 得到关键认知：c/x/t 三个是互斥的"模式"，必须选一个

# 第 4 步：找出常用修饰参数（40 秒）
tar --help | grep -E '^\s+-(f|v|z|j|J|C|p)\b'
#  -f, --file=ARCHIVE         use archive file or device ARCHIVE   <- 指定文件名
#  -v, --verbose              verbosely list files processed
#  -z, --gzip                 filter through gzip
#  -j, --bzip2
#  -J, --xz
#  -C, --directory=DIR        change to directory DIR              <- 解压到哪

# 第 5 步：看官方示例（30 秒）
man tar | sed -n '/^EXAMPLES/,/^SEE ALSO/p'
#  tar -cf archive.tar foo bar   # Create archive.tar from files foo and bar.
#  tar -tvf archive.tar          # List all files in archive.tar verbosely.
#  tar -xf archive.tar           # Extract all files from archive.tar.

# 第 6 步：自己验证一遍（40 秒）
mkdir -p /tmp/t/{src,dst} && echo hi > /tmp/t/src/a.txt
tar -czvf /tmp/t/a.tar.gz -C /tmp/t/src .        # 打包
tar -tzvf /tmp/t/a.tar.gz                        # 查看，先确认结构再解
tar -xzvf /tmp/t/a.tar.gz -C /tmp/t/dst          # 解包
ls /tmp/t/dst

   ls    -l  --color=auto   /var/log   /tmp
   ^^    ^^  ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^
   命令  短选项  长选项+值      操作数（operand）

   tail  -n 20        app.log
         ^^^^^ 选项 + 它自己的参数

tail -n 20 f            # 短选项 + 空格 + 值
tail -n20 f             # 短选项 + 紧贴值（大多数 GNU 命令支持）
tail --lines=20 f       # 长选项 + 等号 + 值（最清晰，脚本里推荐）
tail --lines 20 f       # 长选项 + 空格 + 值

# 短选项可以聚合（前提是它们都不带值）
ls -l -a -h  ==  ls -lah
tar -c -z -v -f a.tgz .  ==  tar -czvf a.tgz .
#                              ^^^^^ 只有最后的 f 带值，所以 f 必须放最后！
tar -cfzv a.tgz .        # ❌ f 后面紧跟的 z 被当成文件名了

# -- 终止选项解析
grep -- '-v' file        # 搜索字符串 "-v"，而不是把它当选项
rm -- -rf                # 删除名叫 -rf 的文件
git checkout -- file     # 明确表示 file 是路径而不是分支名

# sed 原地编辑：BSD 的 -i 必须带参数（备份后缀），GNU 的不带
sed -i    's/a/b/' f        # GNU（Linux）✅
sed -i '' 's/a/b/' f        # BSD（macOS）✅
sed -i.bak 's/a/b/' f       # 两边都能用 ✅ 这才是可移植写法

# date 加减时间，语法完全不同
date -d '+1 day' +%F        # GNU
date -v+1d +%F              # BSD

# 其他常见差异
ls --color=auto             # GNU
ls -G                       # BSD
readlink -f path            # GNU（macOS 需要 coreutils 里的 greadlink）
xargs -r                    # GNU 有 --no-run-if-empty，BSD 没有
stat -c '%s' f              # GNU
stat -f '%z' f              # BSD

# 在 macOS 上装 GNU 版（命令带 g 前缀）
brew install coreutils gnu-sed findutils
gsed -i 's/a/b/' f

ls /tmp >/dev/null; echo $?
# 0            <- 0 = 成功

ls /nonexistent 2>/dev/null; echo $?
# 2            <- 非 0 = 失败（具体数字由程序自己定义）

# 亲手验证
bash -c 'exit 0'; echo $?              # 0
nosuchcommand 2>/dev/null; echo $?     # 127
/etc/passwd 2>/dev/null; echo $?       # 126（不可执行）
bash -c 'kill -9 $$'; echo $?          # 137（被 SIGKILL）
bash -c 'sleep 10' &  kill -TERM $!; wait; echo $?   # 143

# 特定命令的退出码要查 man 的 EXIT STATUS 段
man grep | sed -n '/^EXIT STATUS/,/^FILES/p'
# 0 if a line is selected, 1 if no lines were selected, 2 if error
#                          ^^ 注意：grep 没找到匹配返回 1，这【不是错误】

set -e                          # 任何命令失败就退出
grep foo file                   # 没匹配到 -> 返回 1 -> 整个脚本直接退出！
# ✅ 正确写法
grep foo file || true           # 显式吞掉非零退出码
if grep -q foo file; then ...; fi   # 或者放进条件判断（条件里的失败不触发 set -e）

false | true; echo $?
# 0            <- 只看到 true 的结果，前面的失败被吞了！

false | true; echo "${PIPESTATUS[@]}"
# 1 0          <- 每一段的退出码都在这

set -o pipefail                 # 让管道中任意一段失败都算整体失败
false | true; echo $?
# 1

# 生产脚本的标准三件套（第 17 篇细讲）
set -euo pipefail
#  ^ e=遇错退出  u=用未定义变量报错  o pipefail=管道任意段失败即失败

cmd := exec.Command("git", "status")
err := cmd.Run()
if err != nil {
    var ee *exec.ExitError
    if errors.As(err, &ee) {
        code := ee.ExitCode()          // 命令跑了但返回非 0
        fmt.Printf("退出码 %d\n", code)
        // 被信号杀死时 ExitCode() 返回 -1，要从 ProcessState 里取信号
        if ws, ok := ee.Sys().(syscall.WaitStatus); ok && ws.Signaled() {
            fmt.Printf("被信号 %v 杀死\n", ws.Signal())
        }
    } else {
        // 这类是"根本没跑起来"：命令不存在、权限不足
        fmt.Printf("启动失败: %v\n", err)   // exec: "git": executable file not found in $PATH
    }
}

// ❌ 这样不会工作：管道、通配符、变量展开都是 shell 的功能
exec.Command("ls *.go | wc -l")

// ✅ 需要 shell 特性时显式调用 shell
exec.Command("bash", "-c", "ls *.go | wc -l")
// ⚠️ 但要警惕命令注入：任何用户输入拼进去都是漏洞

// ✅ 不需要 shell 时直接给参数数组（更安全，推荐）
exec.Command("ls", "-l", "/tmp")

!!              # 上一条命令
sudo !!         # 用 sudo 重跑上一条（忘加 sudo 时最常用）
!$              # 上一条命令的最后一个参数（等价 Alt-.）
!^              # 上一条命令的第一个参数
!*              # 上一条命令的所有参数
!vim            # 最近一条以 vim 开头的命令，直接执行
!?log?          # 最近一条包含 log 的命令
^old^new        # 把上一条命令里第一个 old 换成 new 后重跑

# 示例
mkdir /tmp/very/deep/path
cd !$                       # cd /tmp/very/deep/path

# ⚠️ !! 会立即执行，危险操作前先确认
!!:p            # 只打印不执行（:p = print）

history            # 看历史
history 20         # 最近 20 条
history -d 105     # 删掉第 105 条（敲错密码进历史时用）
history -c         # 清空当前会话历史

# 写进 ~/.bashrc 的推荐配置
HISTSIZE=100000                    # 内存里存多少条
HISTFILESIZE=200000                # 文件里存多少条
HISTTIMEFORMAT='%F %T '            # 给历史加时间戳 ← 排查"谁什么时候干了什么"必备
HISTCONTROL=ignoredups:erasedups   # 忽略重复
HISTIGNORE='ls:ll:cd:pwd:exit:history'   # 这些不记
shopt -s histappend                # 多个终端的历史【追加】而不是互相覆盖
PROMPT_COMMAND='history -a'        # 每敲一条就写入文件（不等退出）

# ⚠️ 安全提醒：带密码的命令会明文进历史文件
mysql -uroot -pMyPassword          # ❌ 进了 ~/.bash_history
mysql -uroot -p                    # ✅ 交互式输入
export HISTIGNORE='*password*'     # 或者过滤掉

# 命令前加空格可以不记入历史（需要 HISTCONTROL 含 ignorespace）
HISTCONTROL=ignorespace
 curl -H "Authorization: Bearer secret" ...      # 前面有空格，不进历史

# 补全不只是补文件名，装了 bash-completion 后能补参数、分支名、包名
sudo apt install bash-completion       # Debian 系
sudo dnf install bash-completion       # RHEL 系

git ch<Tab>                # checkout / cherry-pick
systemctl restart ng<Tab>  # nginx.service
kill -<Tab><Tab>           # 列出所有信号名
docker exec -it <Tab>      # 列出运行中的容器名

# Tab 按两次 = 列出所有候选
ls /usr/<Tab><Tab>

# Go 的补全（cobra 生成的 CLI 一般都支持）
mytool completion bash > /etc/bash_completion.d/mytool

# alias：只做简单的字符串替换，不能接收参数
alias ll='ls -alF'
alias gs='git status'
alias ..='cd ..'
alias grep='grep --color=auto'
alias df='df -hT -x tmpfs'

# ⚠️ alias 不接受参数，需要参数就必须用函数
alias mkcd='mkdir -p $1 && cd $1'       # ❌ 不工作，$1 是空的
mkcd() { mkdir -p "$1" && cd "$1"; }    # ✅ 用函数

# 更实用的几个函数
gitlog() { git log --oneline --graph --decorate -"${1:-10}"; }   # 默认 10 条
extract() {                                                       # 万能解压
    case "$1" in
        *.tar.gz|*.tgz) tar -xzvf "$1" ;;
        *.tar.xz)       tar -xJvf "$1" ;;
        *.zip)          unzip "$1" ;;
        *) echo "不认识的格式: $1"; return 1 ;;
    esac
}

# 查看/取消
alias                # 列出全部 alias
alias ll             # 只看一个
unalias ll
type mkcd            # 看函数定义

# ⚠️ 不要在【脚本】里依赖 alias
# 非交互式 shell 默认不展开 alias，脚本里的 alias 不生效（除非 shopt -s expand_aliases）

uname -r                            # 内核版本
uname -m                            # 架构：x86_64 -> Go 的 amd64；aarch64 -> arm64
uname -sr                           # Linux 5.15.0-91-generic
[[ $(uname -m) == aarch64 ]] && echo "ARM 机器"

type -a python3                # 看清有几个 python3、哪个生效
type -t ls                     # alias
command -v docker >/dev/null || { echo "请先装 docker"; exit 1; }
hash -r                        # 换了 go 的安装位置后必做
enable -a | head               # 所有 builtin 列表
compgen -c | sort -u | wc -l   # 当前能敲的命令总数（含 alias/函数/builtin）
compgen -b                     # 只列 builtin
compgen -A function            # 只列函数

man 2 openat                        # 系统调用
man 5 sshd_config                   # 配置文件格式
man 7 epoll                         # 概念长文
man -k 'socket' -s 2,3              # 在系统调用和库函数里搜 socket
man -w bash                         # /usr/share/man/man1/bash.1.gz
MANPAGER='less -R' man ls           # 保留颜色
MANWIDTH=100 man ls                 # 限制宽度（宽屏上更易读）
LANG=C man ls                       # 强制英文手册（中文翻译常常过时）

apk add man-pages mandoc            # Alpine 上手动装
# 或者退回 --help、busybox 的内置帮助、以及在线手册 man7.org

env | sort | less                       # 通读当前环境
env -i bash --noprofile --norc          # 一个"干净"的 shell，排查配置文件问题
env -u http_proxy curl example.com      # 临时绕过代理
TZ=UTC date                             # 只影响这条命令
set -x; ls /tmp; set +x                 # 看命令展开成了什么
sudo tr '\0' '\n' < /proc/1234/environ  # 看运行中进程的环境（容器排查常用）

hostnamectl                          # 主机名 + 系统 + 内核 + 架构 + 虚拟化（systemd 系）
hostnamectl set-hostname web-01      # 改主机名（持久化）
cat /etc/os-release                  # 发行版信息（最可靠）
lsb_release -a                       # 同上（需装 lsb-release 包，不推荐依赖）
cat /proc/version                    # 内核版本 + 编译器版本
cat /proc/cpuinfo | grep -c processor    # 逻辑 CPU 数
nproc                                # 同上，更简洁（⚠️ 容器里返回宿主机核数！见下）
free -h                              # 内存
uptime                               # 运行时长 + 平均负载
who / w                              # 谁登录着
id                                   # 当前用户的 uid/gid/组
getconf ARG_MAX                      # 命令行参数的最大长度
getconf PAGE_SIZE                    # 内存页大小（4096）
getconf -a | head -30                # 所有系统配置常量
timedatectl                          # 时间、时区、NTP 同步状态

# 容器限制 1 核，但
nproc                                # 64      <- 看到的是宿主机
# 结果：Go 的 GOMAXPROCS 默认取 nproc = 64，而实际只能用 1 核，
#       导致大量无效的 goroutine 抢占与上下文切换，尾延迟变差

# ✅ 解法：用 automaxprocs 让 GOMAXPROCS 感知 cgroup 限额
# import _ "go.uber.org/automaxprocs"

# 手动查真实限额（cgroup v2）
cat /sys/fs/cgroup/cpu.max           # 100000 100000  -> 1 核
cat /sys/fs/cgroup/memory.max        # 536870912      -> 512MB