Bash 速查表:100+ Shell 脚本命令和习语 (Linux 和 macOS 都能跑)

name="Lei Li"

count=42

today=$(date +%F)

export PATH="$HOME/bin:$PATH"

export EDITOR=vim

echo "Hello, ${name}!"

file="${base}_${date}.log"

port="${PORT:-8080}"

name="${1:-world}"   # default first arg

: "${LOG_DIR:=/var/log/app}"   # ensure LOG_DIR is set

: "${API_KEY:?need to set API_KEY in env}"

args="${DEBUG:+--verbose}"   # add --verbose only if DEBUG is set

path="${path//\\//}"   # backslashes to forward slashes

safe="${name// /_}"

file=/path/to/file.tar.gz

echo "${file##*/}"   # file.tar.gz

echo "${file#*/}"    # path/to/file.tar.gz

file=archive.tar.gz

echo "${file%.gz}"     # archive.tar

echo "${file%%.*}"     # archive

s="hello"

echo "${#s}"   # 5

s="abcdefgh"

echo "${s:2:3}"   # cde

echo "${s:(-3)}"  # fgh (last 3)

s="hello"

echo "${s^^}"   # HELLO

echo "${s,,}"   # hello (already)

echo $RANDOM

echo $((RANDOM % 100))   # 0-99

tmp="/tmp/job-$RANDOM"

readonly VERSION=1.2.3

readonly LOG_DIR=/var/log/app

unset TMPDIR

unset -f my_function   # also unsets a function

p="a.b.c"

echo "${p/./_}"   # a_b.c

echo "${p//./_}"  # a_b_c

s="test.log"

echo "${s/#test/prod}"   # prod.log

echo "${s/%.log/.txt}"   # test.txt

APP_HOST=a; APP_PORT=b

for v in "${!APP_@}"; do echo "$v=${!v}"; done

path="/usr/bin"

ref="path"

echo "${!ref}"   # /usr/bin

declare -i n

n="3 * 4"

echo "$n"   # 12

declare -r MAX=100

MAX=200   # bash: MAX: readonly variable

# args: a b c d

echo "${@:2}"     # b c d

echo "${@:2:2}"   # b c

fill() { local -n out=$1; out=(x y z); }

fill result

echo "${result[@]}"   # x y z

if (( BASH_VERSINFO[0] < 4 )); then
  echo "need bash 4+" >&2; exit 1
fi

die() { echo "[$FUNCNAME:${BASH_LINENO[0]}] $*" >&2; exit 1; }

if [[ -f config.yaml ]]; then echo "found"; fi

if [[ "$user" == "root" ]]; then echo "boss"; fi

if [[ "$name" == "alice" ]]; then ... fi

if [[ "$file" == *.log ]]; then ...   # glob match, no quotes

if [[ "$env" != "prod" ]]; then echo "safe to delete"; fi

if [[ "$ip" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then echo "looks like ipv4"; fi

if [[ "$s" =~ ^([a-z]+)=([0-9]+)$ ]]; then echo "${BASH_REMATCH[1]}=${BASH_REMATCH[2]}"; fi

if (( count > 10 )); then echo "many"; fi

if (( a + b == 100 )); then echo "match"; fi

if [[ "$age" -ge 18 ]]; then echo "adult"; fi

[[ -f /etc/hosts ]] && echo "exists"

[[ -d "$HOME/.config" ]] || mkdir -p "$HOME/.config"

[[ -e /tmp/lock ]] && exit 1

[[ -z "$NAME" ]] && NAME="anon"

if [[ -n "$DEBUG" ]]; then set -x; fi

ping -c1 host && echo "up" || echo "down"

[[ -d build ]] || mkdir build

if ! grep -q "ok" status.log; then echo "missing ok line"; fi

while ! curl -fs http://app/health; do sleep 1; done

case "$1" in
  start) start_service ;;
  stop)  stop_service ;;
  *)     echo "usage: $0 start|stop"; exit 1 ;;
esac

if [[ -f config && -r config ]]; then echo "readable"; fi

if [[ src.c -nt build/src.o ]]; then
  echo "need rebuild"
fi

[[ -x "$(command -v git)" ]] && echo "git runnable"

[[ -w /etc/hosts ]] || echo "need sudo to edit hosts"

curl -o out.json "$url"

[[ -s out.json ]] || { echo "empty download" >&2; exit 1; }

if [[ -t 1 ]]; then COLOR=1; else COLOR=0; fi

x=""

[[ -v x ]] && echo "x is set (but empty)"

[[ -v y ]] || echo "y is unset"

case "$ans" in
  y|Y|yes) proceed ;;
  n|N|no)  abort ;;
  *)       echo "?" ;;
esac

shopt -s nocasematch

[[ "HELLO" == hello ]] && echo "match"

shopt -u nocasematch

[[ "apple" < "banana" ]] && echo "apple first"

for env in dev staging prod; do
  echo "deploying $env"
done

shopt -s nullglob

for f in *.log; do
  gzip "$f"
done

for ((i=1; i<=5; i++)); do
  echo "attempt $i"
done

for pid in $(pgrep nginx); do
  echo "nginx pid: $pid"
done

while read -r line; do
  echo "got: $line"
done < urls.txt

attempts=0

while ! curl -fs http://app/health; do
  ((attempts++))
  (( attempts > 30 )) && exit 1
  sleep 1
done

until ping -c1 -W1 host >/dev/null 2>&1; do sleep 1; done

for f in *; do
  [[ -d "$f" ]] || continue
  [[ "$f" == "stop" ]] && break
  echo "$f"
done

select env in dev staging prod quit; do
  [[ "$env" == "quit" ]] && break
  echo "you chose $env"
done

for i in {1..5}; do echo "$i"; done

for i in {0..100..10}; do echo "$i"; done

while IFS=, read -r name age role; do
  echo "$name ($age) is a $role"
done < team.csv

n=5

for i in $(seq 1 "$n"); do echo "$i"; done

while :; do
  read -r line || break
  echo "got: $line"
done

for d in /var/log/*/; do
  echo "dir: ${d%/}"
done

while read -r user uid rest; do
  echo "$user has uid $uid"
done < <(getent passwd)

find . -name "*.tmp" -print0 | while IFS= read -r -d "" f; do
  rm -- "$f"
done

files=("a b.txt" "c.txt")

for f in "${files[@]}"; do echo "[$f]"; done

for i in 1 2 3; do
  for j in a b c; do
    [[ "$j" == b ]] && continue 2
    echo "$i$j"
  done
done

coproc BC { bc -l; }

echo "2^10" >&"${BC[1]}"

read -r ans <&"${BC[0]}"

echo "$ans"   # 1024

greet() {
  echo "Hello, $1!"
}

greet "Lei"   # → Hello, Lei!

function deploy {
  echo "deploying $1 to $2"
}

copy() {
  cp "$1" "$2"
}

run_with_logging() {
  echo "[$(date)] running: $*"
  "$@"
}

greet() {
  local who="$1"
  echo "Hello, $who"
}

is_valid() {
  [[ "$1" =~ ^[0-9]+$ ]] && return 0 || return 1
}

if is_valid "$x"; then echo ok; fi

get_timestamp() { date +%s; }

now=$(get_timestamp)

echo "now is $now"

declare -f greet

declare -F | head   # list all defined functions

parse() {
  local -a parts
  IFS=: read -ra parts <<< "$1"
  echo "${#parts[@]} fields"
}

cmd="$1"; shift

echo "running $cmd with: $*"

set -- one two three

echo "$1 $3"   # one three

set --   # now $# is 0

build() {
  local out
  out=$(make 2>&1) || { echo "$out" >&2; return 1; }
}

greet() {
  local OPTIND opt loud=0
  while getopts "l" opt; do
    case $opt in l) loud=1 ;; esac
  done
  shift $((OPTIND-1))
  (( loud )) && echo "HELLO $1" || echo "hi $1"
}

greet() { echo hi; }

unset -f greet

greet   # bash: greet: command not found

ls > files.txt

date >> log.txt   # append

make 2> build-errors.log

cmd 2>/dev/null   # discard errors

build.sh > build.log 2>&1

cmd &> file   # bash shortcut for the same thing

./test.sh &> test.log

mysql -u root db < schema.sql

while read -r line; do echo "$line"; done < input.txt

cat <<EOF > config.yaml
name: app
port: 8080
EOF

cat <<'EOF'
This $will not expand and `nor will this`.
EOF

grep -c "ERROR" <<< "$log"

tr a-z A-Z <<< "hello"

#!/bin/bash
exec > script.log 2>&1
echo "this goes to script.log"

# tee pattern:
exec > >(tee script.log) 2>&1

find / -name foo 2>/dev/null

which gcc &>/dev/null && echo "have gcc"

echo "$(date): started" >> run.log

cat extra.txt >> combined.txt

exec 3< data.txt

read -r first <&3

read -r second <&3

exec 3<&-

make 2>&1 | tee build.log

gen() {
	cat <<-EOF
		line one
		line two
	EOF
}

> app.log        # empty the log

: > /tmp/marker  # create/empty a marker file

# send only stdout (not stderr) down a pipe to grep:
noisy_cmd 3>&1 1>&2 2>&3 | grep -v warning

read -r version < VERSION

echo "building $version"

ps aux | grep nginx

cat access.log | awk '{print $7}' | sort | uniq -c | sort -rn

make |& tee build.log

long_task &

pid=$!

# do other work

wait $pid

today=$(date +%F)

count=$(grep -c ERROR app.log)

files=$(find . -name "*.py" | head -5)

date=`date +%F`   # works but legacy

echo "Today: $(date +%F)"   # better

diff <(sort a.txt) <(sort b.txt)

comm -12 <(sort users-old) <(sort users-new)

set -euo pipefail

curl -fsS bad-url | jq .   # without pipefail, jq exit 0 hides curl failure

make 2>&1 | tee build.log

echo "192.168.1.1 host" | sudo tee -a /etc/hosts

( cd /tmp && tar xzf "$tarball" )   # the parent shell stays where it was

{ echo "header"; cat file; echo "footer"; } > out.txt

job1 & job2 & job3 &

wait   # block until all three done

echo "all finished"

download a.url & download b.url &

wait

echo "both downloaded"

curl -fsS "$url" | gzip > out.gz

echo "curl=${PIPESTATUS[0]} gzip=${PIPESTATUS[1]}"

cat urls.txt | xargs -P4 -n1 curl -sO

find . -name "*.bak" -print0 | xargs -0 rm -v

diff <(curl -s host1/v) <(curl -s host2/v)

diff <(echo "$a") <(echo "$b")

read -r first <<< "$line"

read -r n < <(wc -l < file)

s="hello"

echo "${#s} chars"

echo -n "$s" | wc -c

IFS=":" read -ra dirs <<< "$PATH"

for d in "${dirs[@]}"; do echo "$d"; done

printf -v fname "report-%s-%02d.csv" "$dept" "$month"

echo "$fname"   # report-sales-05.csv

name="hello world"

safe="${name// /_}"

echo "$safe"   # hello_world

if [[ "$file" == /etc/* ]]; then echo "system config"; fi

if [[ "$url" == https://* ]]; then ...; fi

upper=$(tr "a-z" "A-Z" <<< "$name")

echo "$upper"

printf "%s\n" "-n looks like a flag"

printf "%s=%s\n" key value

printf "run: %q %q\n" "$cmd" "$arg with space"

s="   hi   "

lead="${s#"${s%%[![:space:]]*}"}"

echo "[$lead]"   # [hi   ]

IFS= read -rd "" content < notes.md

echo "${#content} bytes read"

is_int() { [[ "$1" =~ ^-?[0-9]+$ ]]; }

is_int "42" && echo ok

is_int "4a" || echo "not an int"

mapfile -t hits < <(grep -n TODO src.py)

echo "${#hits[@]} TODOs"

set -euo pipefail

IFS=$'\n\t'   # the "unofficial bash strict mode" header

set -u

echo "$undefined"   # bash: undefined: unbound variable

set -x

name="lei"

echo "hello $name"

# stderr: + name=lei
#         + echo 'hello lei'

set -o pipefail

curl bad-url | jq .   # now fails properly when curl fails

tmp=$(mktemp)

trap "rm -f \"$tmp\"" EXIT

# tmp gets removed even if the script crashes

trap "echo '^C — bye'; exit 130" INT

trap "stop_server; exit" TERM

exit 0

exit 1   # generic failure

[[ $# -eq 0 ]] && { echo "need an arg"; exit 2; }

ping -c1 host >/dev/null

rc=$?

echo "ping returned $rc"

time make build

time (find /usr | wc -l)

set -e

trap "echo \"failed at line $LINENO\" >&2" ERR

false   # triggers the trap

trap cleanup EXIT

# ... later, when no longer needed:

trap - EXIT

set +e

might_fail   # do not abort on failure here

rc=$?

set -e

#!/usr/bin/env bash
# set up env, then hand off:
export APP_ENV=prod
exec ./server "$@"

timeout 5 long_task

case $? in
  0) echo ok ;;
  124) echo "timed out" ;;
esac

timeout 30 curl -s "$url" || echo "slow endpoint"

timeout -k 5s 60s ./batch.sh

set -Eeuo pipefail

trap "echo err >&2" ERR

f() { false; }

f   # now the trap fires

#!/usr/bin/env bash

set -euo pipefail

IFS=$'\n\t'

while getopts ":hf:v" opt; do
  case $opt in
    h) echo "usage: ..."; exit 0 ;;
    f) file="$OPTARG" ;;
    v) verbose=1 ;;
    \?) echo "bad flag: -$OPTARG" >&2; exit 2 ;;
  esac
done

shift $((OPTIND - 1))   # consume parsed flags

while [[ $# -gt 0 ]]; do
  case "$1" in
    --port)  port="$2"; shift 2 ;;
    --port=*) port="${1#*=}"; shift ;;
    --) shift; break ;;
    *) args+=("$1"); shift ;;
  esac
done

tmp=$(mktemp)

trap "rm -f \"$tmp\"" EXIT

curl -o "$tmp" https://example.com/data.json

RED=$'\033[31m'

RESET=$'\033[0m'

[[ -t 1 ]] || RED='' RESET=''   # disable colors when piped

echo "${RED}ERROR${RESET}: bad config"

for i in {1..100}; do
  pct=$i
  bar=$(printf "%.0s#" $(seq 1 $((pct/2))))
  printf "\r[%-50s] %3d%%" "$bar" "$pct"
  sleep 0.05
done
echo

if [[ $# -lt 2 ]]; then
  echo "usage: $0 <src> <dst>" >&2
  exit 2
fi

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "$SCRIPT_DIR/lib.sh"

if ! command -v jq >/dev/null; then
  echo "need jq, please install" >&2
  exit 1
fi

read -p "Continue? [y/N] " ans

[[ "${ans,,}" == "y" || "${ans,,}" == "yes" ]] || exit 0

log() { echo "[$(date +%H:%M:%S)] $*" >&2; }

log "starting deploy"

log "done"

: "${DEPLOY_ENV:?set DEPLOY_ENV to dev|prod}"

: "${TOKEN:?missing TOKEN}"

cd "$(dirname "$0")" || exit 1

source ./config.sh

usage() {
  cat <<EOF
usage: $0 [-v] <src> <dst>
  -v   verbose
EOF
}

[[ "$1" == "-h" ]] && { usage; exit 0; }

shopt -s globstar

for f in src/**/*.test.ts; do echo "$f"; done

shopt -s extglob

rm -- !(*.keep)        # delete everything except *.keep

echo @(jpg|png|gif)    # any of these

workdir=$(mktemp -d)

cleanup() { rm -rf "$workdir"; }

trap cleanup EXIT INT TERM

set -euo pipefail

IFS=$'\n\t'

flock -n /tmp/job.lock ./nightly.sh || echo "already running"

read -rsp "Password: " pw

echo

curl -u "user:$pw" "$url"

declare -a fruits=(apple banana cherry)

echo "${fruits[0]}"   # apple

declare -A color

color[apple]=red

color[grape]=purple

echo "${color[apple]}"   # red

envs=(dev staging prod)

echo "${envs[1]}"   # staging

files=()

for f in *.log; do files+=("$f"); done

echo "${#files[@]} log files"

for f in "${files[@]}"; do
  echo "$f"
done

echo "${#files[@]} files matched"

if (( ${#errors[@]} > 0 )); then echo "had errors"; fi

for i in "${!arr[@]}"; do
  echo "$i -> ${arr[$i]}"
done

for k in "${!color[@]}"; do
  echo "$k is ${color[$k]}"
done

arr=(a b c d)

unset "arr[1]"

echo "${arr[@]}"   # a c d

echo "${!arr[@]}"   # 0 2 3

mapfile -t lines < urls.txt

echo "read ${#lines[@]} urls"

a=(a b c d e)

echo "${a[@]:1:2}"   # b c

echo "${a[@]: -2}"   # d e (note the space)

a=(x y z)

unset "a[1]"

a=("${a[@]}")   # now indices are 0,1 again

echo "${!a[@]}"   # 0 1

parts=(2026 05 30)

IFS=-; echo "${parts[*]}"; unset IFS   # 2026-05-30

a=(one "two words" three)

declare -p a   # declare -a a=([0]="one" [1]="two words" [2]="three")

declare -A seen

for w in a b a c a; do seen[$w]=$(( ${seen[$w]:-0} + 1 )); done

echo "${seen[a]}"   # 3

declare -A cfg=([host]=a [port]="")

[[ -v cfg[port] ]] && echo "port key exists"

[[ -v cfg[tls] ]] || echo "no tls key"

readarray -t -d "" files < <(find . -name "*.log" -print0)

echo "${#files[@]} logs"

cp "$src" "$dst"   # safe

for f in "$@"; do echo "$f"; done   # safe

cd "$build_dir" && rm -rf *   # safe

pushd "$dir" || exit; do_work; popd

# wrong:
# cat file | while read l; do n=$((n+1)); done
# right:
while read -r l; do n=$((n+1)); done < file
echo "$n"

set -euo pipefail

critical_cmd || { echo "critical failed" >&2; exit 1; }

shopt -s nullglob

for f in *.log; do echo "$f"; done

printf "a\nb" | wc -l   # 1 (!)

printf "a\nb" | awk "END{print NR}"   # 2

(( age >= 18 ))   # numeric

[[ "$name" > "alice" ]]   # alphabetic

# inside lib.sh:
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  echo "run directly"
else
  echo "sourced from $0"
fi

bash --version   # check yours

#!/opt/homebrew/bin/bash   # macOS modern bash

x=outer

(x=inner; echo "in: $x")   # in: inner

echo "out: $x"             # out: outer

# portable long-option parsing:
while [[ $# -gt 0 ]]; do
  case "$1" in
    --file) file="$2"; shift 2 ;;
    --) shift; break ;;
    *) shift ;;
  esac
done

printf "no newline"

printf "%b\n" "tab\there"

out=$(grep ERR log) || { echo "grep failed"; exit 1; }

mapfile -t names < <(ls)   # safe, line-by-line

out=$(printf "a\n\n")

echo "${#out}"   # 1 — the two newlines are gone

[[ -n "${dir:-}" ]] || { echo "dir unset" >&2; exit 1; }

rm -rf -- "$dir"

while read -r l || [[ -n "$l" ]]; do echo "$l"; done < no-trailing-newline.txt

log="$HOME/app.log"   # right

log=~/app.log         # also right (unquoted)

[[ "$a" == "$b" ]]   # safe even if both empty

#!/usr/bin/env bash
export PATH="/usr/local/bin:/usr/bin:/bin"

# in lib.sh, guard "run vs sourced":
[[ "${BASH_SOURCE[0]}" != "$0" ]] && return 0