CLI on Bill.Lin's Notes

openssl — 憑證、加密與 TLS 除錯命令列指南

Sun, 23 Aug 2026 00:00:00 +0800

macOS 上有兩套 openssl 可能同時存在，指令語法看起來一樣，但底層實作不同、行為也會有差異，先搞清楚自己在用哪一套，後面踩坑機率會少很多。

macOS LibreSSL vs Homebrew OpenSSL

macOS 內建的 /usr/bin/openssl 其實不是正牌 OpenSSL，而是 LibreSSL（OpenSSL 的 fork）：

1
2

/usr/bin/openssl version
# LibreSSL 3.3.6

透過 Homebrew 安裝的才是正牌 OpenSSL：

brew install openssl@3

/opt/homebrew/bin/openssl version
# OpenSSL 3.6.3 9 Jun 2026 (Library: OpenSSL 3.6.3 9 Jun 2026)

Homebrew 預設不會 link openssl@3（避免覆蓋系統版本），所以裝完之後單純打 openssl 很可能還是吃到 /usr/bin/openssl（LibreSSL）。確認目前 PATH 解析到哪一個：

which -a openssl
# /opt/homebrew/bin/openssl   <- 如果 Homebrew bin 在 PATH 前面，這行會排第一個
# /usr/bin/openssl

openssl version   # 實際會執行到的那個

如果 which openssl 解析到的不是想要的版本，把 Homebrew 版加進 PATH（放前面）：

jq — 命令列 JSON 處理

Mon, 15 Jan 2024 00:00:00 +0800

安裝

# macOS
brew install jq

# Ubuntu / Debian
sudo apt install jq

# Alpine（Docker 常用）
apk add jq

# 確認版本
jq --version
# jq-1.7.1

基本過濾器

# Pretty print（最常用：curl 結果格式化）
curl -s https://api.github.com/repos/spring-projects/spring-boot | jq '.'

# 取特定欄位
jq '.name'
jq '.stargazers_count'

# 取陣列元素
jq '.[0]'         # 第一個元素
jq '.[-1]'        # 最後一個元素
jq '.[2:5]'       # index 2 到 4（slice）

# 展開陣列（iterate）
jq '.[]'          # 輸出陣列每個元素，各佔一行

# 巢狀欄位
jq '.user.email'
jq '.address.city'

# 多個欄位 → 新物件
jq '{name: .name, email: .user.email}'

# 多個欄位 → array
jq '[.name, .email]'

空值安全

# 欄位不存在時回傳 null，不報錯
jq '.nonexistent'

# 提供預設值（若為 null 則用 "unknown"）
jq '.name // "unknown"'

# optional operator（? 表示若不適用則忽略，不報錯）
jq '.items[]? | .name'

陣列操作

# map：對每個元素套用 filter
jq 'map(.name)'
# 等同於
jq '[.[] | .name]'

# select：過濾符合條件的元素
jq '.[] | select(.age > 18)'
jq '.[] | select(.status == "active")'
jq '.[] | select(.role == "admin" or .role == "superuser")'

# length：陣列長度 / 字串長度 / 物件 key 數
jq 'length'
jq '.items | length'

# sort_by
jq 'sort_by(.name)'
jq 'sort_by(.age) | reverse'   # 降序

# unique_by
jq 'unique_by(.type)'
jq '[.[].type] | unique'        # 取所有 type 的唯一值列表

# group_by
jq 'group_by(.department)'

# flatten（展開巢狀陣列）
jq 'flatten'
jq 'flatten(1)'  # 只展開一層

# first / last
jq 'first(.[] | select(.active))'

字串與格式化

# String interpolation（@string format）
jq '.[] | "\(.name): \(.email)"'

# 傳入變數（避免 shell injection）
jq --arg status "active" '.[] | select(.status == $status)'
jq --argjson min_age 18 '.[] | select(.age > $min_age)'

# 數值格式
jq '.price * 100 | round'       # 四捨五入
jq '.size / 1024 / 1024'        # MB

# 字串操作
jq '.name | ascii_upcase'
jq '.name | ascii_downcase'
jq '.name | ltrimstr("Mr. ")'   # 移除前綴
jq '.name | split(" ") | .[0]'  # 取第一個 token
jq '.tags | join(", ")'         # 陣列轉字串

# 輸出純字串（不含 JSON 引號）
jq -r '.name'

物件操作

# keys / values
jq 'keys'
jq 'values'
jq 'to_entries'     # [{key: "a", value: 1}, ...]
jq 'from_entries'   # [{key,value}] → {a:1}

# has：判斷是否有某 key
jq 'has("email")'
jq '.[] | select(has("avatar_url"))'

# 合併物件
jq '. + {"extra": "field"}'
jq 'reduce .[] as $item ({}; . + $item)'

# del：刪除欄位
jq 'del(.password)'
jq 'del(.users[].password)'

# 重新命名欄位
jq '{id: .user_id, email: .user_email}'

進階：reduce 與 env

# reduce：摺疊陣列
# 計算總和
jq 'reduce .[] as $x (0; . + $x)'

# 讀取環境變數
jq -n 'env.HOME'
jq -n 'env | keys'

# null input（不從 stdin 讀，直接建構）
jq -n '{"timestamp": now | todate, "host": env.HOSTNAME}'

# any / all
jq 'any(.[]; .active)'   # 有任何元素 active
jq 'all(.[]; .verified)' # 所有元素都 verified

CI/CD 實戰範例

GitHub API

# 取最新 release tag
gh api repos/spring-projects/spring-boot/releases/latest | jq -r '.tag_name'

# 列出所有 PR 的 title 與 number
gh api repos/owner/repo/pulls | jq '.[] | "\(.number): \(.title)"'

# 找出所有 open PR 的 author
gh api repos/owner/repo/pulls | jq '[.[] | select(.state == "open") | .user.login] | unique'

# CI 判斷：若無 open issue 則繼續
OPEN_COUNT=$(gh api repos/owner/repo/issues | jq '[.[] | select(.state == "open")] | length')
if [ "$OPEN_COUNT" -gt 0 ]; then echo "Has open issues"; fi

Docker

# 取 image 支援的平台
docker manifest inspect nginx:latest | \
  jq '[.manifests[].platform | "\(.os)/\(.architecture)"]'

# 列出所有 running container 的 name 與 image
docker ps --format '{{json .}}' | jq -s '[.[] | {name: .Names, image: .Image}]'

AWS CLI

# 列出所有 EC2 instance 的 ID 與狀態
aws ec2 describe-instances | \
  jq '.Reservations[].Instances[] | {id: .InstanceId, state: .State.Name, type: .InstanceType}'

# 只列出 running 的 instance
aws ec2 describe-instances | \
  jq '[.Reservations[].Instances[] | select(.State.Name == "running") | .InstanceId]'

# 取 ECS service 的 desired / running count
aws ecs describe-services --cluster my-cluster --services my-service | \
  jq '.services[0] | {desired: .desiredCount, running: .runningCount}'

# 從 Secrets Manager 取值（已解碼的 JSON secret）
aws secretsmanager get-secret-value --secret-id my-secret | \
  jq -r '.SecretString' | jq '.DB_PASSWORD'

Kubernetes

# 列出所有 pod 及其狀態
kubectl get pods -o json | \
  jq '.items[] | {name: .metadata.name, status: .status.phase}'

# 找出 Crash 的 pod
kubectl get pods -o json | \
  jq '[.items[] | select(.status.phase == "CrashLoopBackOff") | .metadata.name]'

Helm / 部署腳本

# 比較兩個 JSON 的差異
diff <(jq -S '.' file1.json) <(jq -S '.' file2.json)

# 從 package.json 取版本號
VERSION=$(jq -r '.version' package.json)
docker build -t "my-app:${VERSION}" .

jq vs 其他工具

工具	優點	缺點	適用
`jq`	快速、語法簡潔、shell-friendly	學習曲線、複雜邏輯難讀	CLI 腳本、CI/CD
`python -m json.tool`	無需安裝、pretty print	只能格式化，無法過濾	純格式化
`fx`	互動式、支援 JS 語法	需要 Node.js	互動探索
`gron`	把 JSON 變成 grep-able 行	需要配合 grep/sed	搜尋特定值
Python/`requests`	完整語言能力	需要寫腳本	複雜邏輯

常見陷阱

數值精度

# jq 使用 IEEE 754 double，大整數會失去精度
echo '{"id": 9007199254740993}' | jq '.id'
# 輸出：9007199254740992  ← 精度丟失！

# 解法：用字串處理大整數
echo '{"id": "9007199254740993"}' | jq '.id'
# 輸出："9007199254740993"  ← 正確

2^53 = 9007199254740992，超過此值的整數用 jq 處理會失去精度，Twitter ID、雪花算法 ID 等大整數要特別注意。

Xargs 命令完整指南：Linux 參數處理與並行執行的強大工具

Wed, 02 Nov 2022 23:05:25 +0800

概述

xargs（eXtended ARGuments）是 Unix/Linux 系統中的強大工具，用於從標準輸入讀取資料並將其作為參數傳遞給其他命令。它解決了命令行參數長度限制的問題，並提供了並行處理能力，是管道操作和批次處理的重要工具。

核心特徵

參數轉換：將輸入流轉換為命令參數
批次處理：支援分批執行大量操作
並行執行：可同時執行多個程序提升效率
安全處理：正確處理包含空格的檔案名稱
靈活控制：豐富的選項控制執行行為

基本語法

`1`	`xargs [選項] [命令 [初始參數]]`

工作原理

# 基本概念
command1 | xargs command2

# 等同於
command2 arg1 arg2 arg3 ...

簡單範例

# 預設行為（使用 echo）
echo "a b c d" | xargs              # 輸出: a b c d

# 指定命令
echo "file1 file2 file3" | xargs ls -l

# 從檔案讀取
cat filelist.txt | xargs rm -f

# 與 find 組合
find . -name "*.tmp" | xargs rm -f

核心選項詳解

基本控制選項

# -t (--verbose) - 顯示執行的命令
echo "a b c" | xargs -t rm
# 輸出: rm a b c
# 然後執行 rm a b c

# -p (--interactive) - 交互式確認
echo "file1 file2" | xargs -p rm
# 輸出: rm file1 file2?...
# 等待使用者輸入 y/n

# -r (--no-run-if-empty) - 空輸入時不執行
echo "" | xargs -r echo "執行了"    # 不會執行
echo "" | xargs echo "執行了"       # 會執行

# --help - 顯示幫助資訊
xargs --help

參數分組選項

# -n max-args - 限制每次執行的參數數量
echo "1 2 3 4 5 6" | xargs -n 2 echo
# 輸出:
# 1 2
# 3 4
# 5 6

# -L max-lines - 限制每次處理的行數
printf "a\nb\nc\nd\n" | xargs -L 2 echo
# 輸出:
# a b
# c d

# -s max-chars - 限制命令行長度
echo "very long arguments here" | xargs -s 20 echo

分隔符處理

# -d delimiter - 自訂分隔符
echo "a,b,c,d" | xargs -d, echo
# 輸出: a b c d

# -0 (--null) - 使用 null 字元作分隔符
find . -name "*.txt" -print0 | xargs -0 ls -l

# 處理包含空格的檔案名
echo -e "file 1.txt\nfile 2.txt" | xargs -d'\n' ls -l

替換字串選項

# -I replace-str - 指定替換字串
echo "file1 file2 file3" | xargs -I {} cp {} {}.backup

# -i 或 -I{} - 使用 {} 作為替換字串
ls *.txt | xargs -I{} cp {} backup/{}

# 複雜替換範例
find . -name "*.log" | xargs -I{} sh -c 'echo "Processing: {}"; gzip {}'

並行處理選項

# -P max-procs - 並行執行
echo "1 2 3 4 5" | xargs -n 1 -P 3 sleep
# 同時執行最多 3 個 sleep 命令

# -P 0 - 無限制並行
seq 1 10 | xargs -n 1 -P 0 echo

# 實際並行範例
find . -name "*.jpg" | xargs -n 1 -P 4 -I{} convert {} {}.thumb.jpg

實戰應用場景

1. 檔案管理操作

# 批次刪除檔案
find /tmp -name "*.tmp" -mtime +7 | xargs rm -f

# 批次複製檔案
ls *.txt | xargs -I{} cp {} backup/

# 批次移動檔案
find . -name "*.old" | xargs -I{} mv {} archive/

# 批次重命名
ls *.jpeg | xargs -I{} sh -c 'mv "$1" "${1%.jpeg}.jpg"' _ {}

# 建立多個目錄
echo "dir1 dir2 dir3" | xargs mkdir -p

# 修改檔案權限
find /var/www -name "*.php" | xargs chmod 644
find /var/www -type d | xargs chmod 755

# 批次壓縮檔案
find . -name "*.log" -size +100M | xargs -I{} gzip {}

2. 文本處理

# 批次搜尋文本
find . -name "*.txt" | xargs grep -l "pattern"

# 批次替換文本
find . -name "*.conf" | xargs sed -i 's/old/new/g'

# 統計行數
find . -name "*.py" | xargs wc -l

# 批次編碼轉換
find . -name "*.txt" | xargs -I{} iconv -f gbk -t utf8 {} -o {}.utf8

# 批次格式化程式碼
find . -name "*.js" | xargs prettier --write

# 批次檢查語法
find . -name "*.sh" | xargs -I{} bash -n {}

3. 系統管理

# 批次殺死程序
ps aux | grep "process_name" | awk '{print $2}' | xargs kill

# 批次服務重啟
echo "nginx apache2 mysql" | xargs -n 1 systemctl restart

# 批次安裝軟體包
cat package_list.txt | xargs apt-get install -y

# 磁碟使用統計
find /var/log -name "*.log" | xargs du -sh

# 批次下載檔案
cat urls.txt | xargs -n 1 -P 5 wget

# 批次備份
echo "/etc /var/log /home" | xargs -I{} tar -czf {//}.tar.gz {}

4. 開發與部署

# 批次編譯
find . -name "*.c" | xargs gcc -o output

# 批次測試
find . -name "*_test.py" | xargs -I{} python {}

# 批次部署
cat server_list.txt | xargs -I{} scp deploy.sh user@{}:/tmp/

# 批次執行遠程命令
cat servers.txt | xargs -I{} ssh {} "uptime"

# 批次 Git 操作
find . -name ".git" -type d | xargs -I{} sh -c 'cd {} && git pull'

# 批次建構 Docker 映像
ls */Dockerfile | xargs -I{} sh -c 'cd $(dirname {}) && docker build -t $(basename $(pwd)) .'

5. 監控與日誌

# 批次監控檔案變化
find /var/log -name "*.log" | xargs -I{} tail -f {}

# 批次日誌分析
find . -name "access.log*" | xargs zcat | grep "ERROR"

# 批次清理日誌
find /var/log -name "*.log" -size +100M | xargs truncate -s 0

# 系統資訊收集
echo "/proc/cpuinfo /proc/meminfo /proc/loadavg" | xargs -I{} sh -c 'echo "=== {} ==="; cat {}'

# 批次檢查服務狀態
echo "nginx mysql redis" | xargs -I{} systemctl status {}

進階技巧

1. 複雜命令組合

# 多命令執行
find . -name "*.log" | xargs -I{} sh -c 'echo "Processing {}"; wc -l {}; echo "Done"'

# 條件執行
find . -name "*.txt" | xargs -I{} sh -c 'if [ -s "{}" ]; then echo "Non-empty: {}"; fi'

# 錯誤處理
find . -name "*.sh" | xargs -I{} sh -c 'bash -n "{}" || echo "Syntax error in {}"'

# 結果收集
find . -name "*.py" | xargs -I{} sh -c 'echo "{}: $(wc -l < "{}")"' | sort -k2 -nr

# 管道組合
find . -name "*.log" | xargs -I{} sh -c 'cat "{}" | grep ERROR | wc -l' | awk '{sum+=$1} END {print sum}'

2. 並行處理最佳化

# CPU 密集型任務
seq 1 100 | xargs -n 1 -P $(nproc) sh -c 'echo "Processing $1"; sleep 1; echo "Done $1"' _

# I/O 密集型任務
cat urls.txt | xargs -n 1 -P 10 -I{} sh -c 'echo "Downloading {}"; wget -q {}'

# 記憶體管理
find . -name "*.big" | xargs -n 1 -P 2 -I{} process_large_file {}

# 並行日誌處理
find /var/log -name "*.log" | xargs -n 1 -P 4 -I{} sh -c 'gzip "{}" && echo "Compressed {}"'

# 負載均衡
seq 1 1000 | xargs -n 10 -P 8 -I{} process_batch {}

3. 安全性考慮

# 處理特殊字元
find . -name "*.txt" -print0 | xargs -0 ls -l

# 避免命令注入
echo "file; rm -rf /" | xargs -I{} sh -c 'ls "$1"' _ {}

# 參數驗證
cat files.txt | xargs -I{} sh -c 'if [ -f "$1" ]; then process "$1"; fi' _ {}

# 路徑安全
find . -name "*.conf" | xargs -I{} sh -c 'realpath "$1" | grep "^/safe/path" && process "$1"' _ {}

4. 效能優化

# 批次大小優化
find . -name "*.txt" | xargs -n 100 process_files

# 記憶體限制
find . -name "*.log" | xargs -s 4096 process_with_memory_limit

# 並行數調整
find . -name "*.jpg" | xargs -n 1 -P $(nproc) optimize_image

# 緩衝區優化
find . -name "*.data" | xargs -n 50 -P 4 process_data_batch

錯誤處理與除錯

1. 常見問題

# 問題：參數過長
# 解決：使用 -s 限制或分批處理
find . -name "*.txt" | xargs -s 1000 rm

# 問題：檔案名包含空格
# 解決：使用 -0 和 -print0
find . -name "*.txt" -print0 | xargs -0 rm

# 問題：空輸入執行
# 解決：使用 -r 選項
echo "" | xargs -r echo "不會執行"

# 問題：並行競爭
# 解決：使用適當的鎖機制
find . -name "*.log" | xargs -n 1 -P 4 -I{} flock /tmp/lock process {}

2. 除錯技巧

# 使用 -t 查看執行命令
find . -name "*.txt" | xargs -t rm

# 使用 -p 交互式確認
find . -name "*.tmp" | xargs -p rm

# 逐步測試
echo "test1 test2" | xargs -n 1 echo

# 檢查參數
find . -name "*.txt" | xargs -I{} echo "Will process: {}"

# 錯誤日誌
find . -name "*.sh" | xargs -I{} sh -c 'bash -n "{}" 2>>error.log || echo "Error in {}"'

3. 效能監控

# 執行時間測量
time find . -name "*.txt" | xargs wc -l

# 並行效能比較
time seq 1 100 | xargs -n 1 sleep 0.1          # 串行
time seq 1 100 | xargs -n 1 -P 10 sleep 0.1    # 並行

# 資源使用監控
find . -name "*.big" | xargs -n 1 -P 4 -I{} sh -c 'echo "Processing {}"; /usr/bin/time -v process {}'

與其他工具整合

1. 與 find 組合

# 基本組合
find /path -name "pattern" | xargs command

# 安全處理
find /path -name "pattern" -print0 | xargs -0 command

# 條件過濾
find /path -name "*.txt" -size +1M | xargs -I{} sh -c 'echo "Large file: {}"'

# 複雜搜尋
find /path -type f -mtime -7 \( -name "*.log" -o -name "*.txt" \) | xargs grep "pattern"

2. 與 grep 組合

# 檔案內容搜尋
find . -name "*.py" | xargs grep -l "import numpy"

# 多模式搜尋
find . -name "*.conf" | xargs grep -E "(error|warning|critical)"

# 統計匹配
find . -name "*.log" | xargs grep "ERROR" | wc -l

# 結果處理
find . -name "*.txt" | xargs grep -H "pattern" | cut -d: -f1 | sort | uniq

3. 與 ssh 組合

# 遠程並行執行
cat servers.txt | xargs -n 1 -P 5 -I{} ssh {} "command"

# 批次檔案傳輸
cat servers.txt | xargs -I{} scp file.txt user@{}:/tmp/

# 遠程監控
cat servers.txt | xargs -I{} ssh {} "uptime; df -h"

# 分布式處理
cat servers.txt | xargs -n 1 -P 10 -I{} ssh {} "process_data input.txt"

實用腳本範例

1. 批次檔案處理腳本

#!/bin/bash
# batch_process.sh - 批次處理檔案

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
INPUT_DIR="${1:-./input}"
OUTPUT_DIR="${2:-./output}"
MAX_PARALLEL="${3:-4}"

# 建立輸出目錄
mkdir -p "$OUTPUT_DIR"

# 批次處理
find "$INPUT_DIR" -name "*.txt" -print0 | \
xargs -0 -n 1 -P "$MAX_PARALLEL" -I{} \
sh -c '
    input_file="$1"
    output_file="'"$OUTPUT_DIR"'/$(basename "$1" .txt).processed.txt"
    echo "Processing: $input_file"
    
    # 處理邏輯
    sed "s/old/new/g" "$input_file" > "$output_file"
    
    echo "Completed: $output_file"
' _ {}

echo "批次處理完成"

2. 系統清理腳本

#!/bin/bash
# system_cleanup.sh - 系統清理腳本

LOG_FILE="/var/log/cleanup.log"
DRY_RUN="${1:-false}"

log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

cleanup_logs() {
    log "開始清理日誌檔案"
    
    if [ "$DRY_RUN" = "true" ]; then
        find /var/log -name "*.log" -size +100M | xargs -I{} echo "Will compress: {}"
    else
        find /var/log -name "*.log" -size +100M | \
        xargs -n 1 -P 4 -I{} sh -c 'gzip "$1" && echo "Compressed: $1"' _ {} | \
        tee -a "$LOG_FILE"
    fi
}

cleanup_temp() {
    log "開始清理臨時檔案"
    
    if [ "$DRY_RUN" = "true" ]; then
        find /tmp -type f -mtime +7 | xargs -I{} echo "Will remove: {}"
    else
        find /tmp -type f -mtime +7 | \
        xargs -r rm -f
    fi
}

cleanup_cache() {
    log "開始清理快取檔案"
    
    if [ "$DRY_RUN" = "true" ]; then
        find /var/cache -name "*.cache" -mtime +30 | xargs -I{} echo "Will remove: {}"
    else
        find /var/cache -name "*.cache" -mtime +30 | \
        xargs -r rm -f
    fi
}

# 主執行
log "開始系統清理 (DRY_RUN: $DRY_RUN)"
cleanup_logs
cleanup_temp
cleanup_cache
log "系統清理完成"

3. 並行下載腳本

#!/bin/bash
# parallel_download.sh - 並行下載腳本

URL_FILE="${1:-urls.txt}"
DOWNLOAD_DIR="${2:-./downloads}"
MAX_PARALLEL="${3:-5}"
TIMEOUT="${4:-30}"

# 檢查輸入檔案
if [ ! -f "$URL_FILE" ]; then
    echo "錯誤：找不到 URL 檔案 $URL_FILE"
    exit 1
fi

# 建立下載目錄
mkdir -p "$DOWNLOAD_DIR"

# 並行下載
cat "$URL_FILE" | \
xargs -n 1 -P "$MAX_PARALLEL" -I{} \
sh -c '
    url="$1"
    dir="$2"
    timeout="$3"
    
    filename=$(basename "$url")
    output_path="$dir/$filename"
    
    echo "開始下載: $url"
    
    if timeout "$timeout" wget -q -O "$output_path" "$url"; then
        echo "下載成功: $filename"
    else
        echo "下載失敗: $url"
        rm -f "$output_path"
    fi
' _ {} "$DOWNLOAD_DIR" "$TIMEOUT"

echo "下載任務完成"

# 統計結果
total_files=$(wc -l < "$URL_FILE")
downloaded_files=$(find "$DOWNLOAD_DIR" -type f | wc -l)
echo "總計: $total_files 個檔案，成功下載: $downloaded_files 個檔案"

效能最佳化

1. 並行度調整

# CPU 綁定任務
CPU_CORES=$(nproc)
find . -name "*.c" | xargs -n 1 -P "$CPU_CORES" gcc -c

# I/O 綁定任務
IO_PARALLEL=$(($(nproc) * 2))
cat urls.txt | xargs -n 1 -P "$IO_PARALLEL" wget

# 混合負載
MIXED_PARALLEL=$(($(nproc) + 2))
find . -name "*.log" | xargs -n 1 -P "$MIXED_PARALLEL" process_log

2. 記憶體管理

# 限制批次大小
find . -name "*.big" | xargs -n 1 process_large_file

# 限制命令行長度
find . -name "*.txt" | xargs -s 4096 process_files

# 分段處理
find . -name "*.data" | split -l 1000 - batch_
for batch in batch_*; do
    cat "$batch" | xargs -n 10 -P 4 process_data
done

3. 網路優化

# 連接池
cat servers.txt | xargs -n 1 -P 10 -I{} ssh -o ControlMaster=auto -o ControlPath=/tmp/ssh-%r@%h:%p {} "command"

# 重試機制
cat urls.txt | xargs -n 1 -I{} sh -c 'for i in {1..3}; do wget "{}" && break; sleep 5; done'

# 頻寬限制
cat large_files.txt | xargs -n 1 -P 2 -I{} rsync --bwlimit=1000 {} destination/

總結

核心優勢

參數處理：解決命令行參數長度限制
批次操作：高效處理大量檔案和資料
並行執行：充分利用多核心系統資源
管道友好：與其他 Unix 工具完美整合
靈活控制：豐富的選項滿足各種需求

最佳實踐

安全第一：處理包含空格的檔案名使用 -0 和 -print0
適當並行：根據任務類型調整並行度
錯誤處理：使用 -r 避免空輸入執行
測試先行：使用 -t 和 -p 選項測試命令
效能監控：測量並優化批次大小和並行度

常用模式記憶

# 基本模式
find . -name "pattern" | xargs command

# 安全模式
find . -name "pattern" -print0 | xargs -0 command

# 並行模式
command | xargs -n 1 -P 4 process

# 替換模式
echo "files" | xargs -I{} cp {} backup/{}

# 交互模式
find . -name "*.tmp" | xargs -p rm

xargs 是命令行批次處理和並行執行的瑞士軍刀，掌握其核心概念和常用技巧，能夠大幅提升 Linux 系統管理和自動化任務的效率。記住：合理使用並行處理能夠顯著提升效能，但要注意資源管理和錯誤處理。

Find 命令完整指南：Linux 檔案搜尋與管理的瑞士軍刀

Tue, 01 Nov 2022 21:59:56 +0800

概述

find 是 Linux/Unix 系統中最強大且最常用的檔案搜尋命令之一。它不僅能夠根據各種條件搜尋檔案和目錄，還能對搜尋結果執行各種操作，是系統管理員和開發者必備的核心工具。

核心特徵

遞歸搜尋：可深入子目錄進行搜尋
多重條件：支援檔名、類型、大小、時間等多種搜尋條件
動作執行：可對搜尋結果執行各種操作
邏輯組合：支援 AND、OR、NOT 等邏輯運算
高效能：針對大型檔案系統優化

基本語法

`1`	`find [搜尋路徑] [搜尋條件] [動作]`

基本使用範例

# 在當前目錄搜尋檔案
find . -name "test.txt"

# 在指定目錄搜尋
find /home/user -name "*.log"

# 忽略大小寫搜尋
find . -iname "README.md"

# 搜尋多個目錄
find /var/log /tmp -name "*.tmp"

依據檔案名稱搜尋

基本檔名搜尋

# 精確檔名匹配
find /home -name "config.conf"

# 萬用字元搜尋
find . -name "*.txt"           # 所有 .txt 檔案
find . -name "test*"           # 以 test 開頭的檔案
find . -name "*backup*"        # 包含 backup 的檔案

# 忽略大小寫
find . -iname "*.PDF"          # 不分大小寫搜尋 PDF 檔案
find . -iname "readme*"        # 不分大小寫搜尋 readme 開頭的檔案

進階檔名搜尋

# 使用正規表達式
find . -regex ".*\.\(jpg\|png\|gif\)$"    # 搜尋圖片檔案
find . -iregex ".*\.\(mp3\|mp4\|avi\)$"   # 不分大小寫搜尋媒體檔案

# 排除特定檔案
find . -name "*.txt" ! -name "temp*"      # 搜尋 txt 但排除 temp 開頭
find . ! -name ".*"                       # 排除隱藏檔案

# 多個條件組合
find . \( -name "*.log" -o -name "*.tmp" \) # OR 條件
find . -name "*.txt" -a -size +1M         # AND 條件

依據檔案類型搜尋

基本檔案類型

# 檔案類型參數說明
# f: 一般檔案    d: 目錄
# l: 符號連結    p: 命名管道 (FIFO)
# s: socket      b: 區塊裝置
# c: 字元裝置

# 搜尋目錄
find /var -type d -name "log*"

# 搜尋一般檔案
find . -type f -name "*.sh"

# 搜尋符號連結
find /usr/bin -type l

# 搜尋空檔案
find /tmp -type f -empty

# 搜尋空目錄
find /home -type d -empty

實際應用範例

# 找出所有 shell 腳本
find /usr/local/bin -type f -name "*.sh" -executable

# 找出所有損壞的符號連結
find /usr -type l ! -exec test -e {} \; -print

# 找出包含特定副檔名的目錄
find . -type d -exec sh -c 'ls "$1"/*.log >/dev/null 2>&1' _ {} \; -print

依據檔案大小搜尋

基本大小搜尋

# 大小單位說明
# c: bytes     k: KB (1024 bytes)
# M: MB        G: GB
# +: 大於      -: 小於      精確值: 等於

# 基本大小搜尋
find . -size 50M                    # 等於 50MB
find . -size +100M                  # 大於 100MB
find . -size -1G                    # 小於 1GB
find /var/log -size +10M -size -100M # 10MB 到 100MB 之間

進階大小操作

# 找出最大的檔案（前 10 個）
find /home -type f -exec ls -la {} \; | sort -k5 -nr | head -10

# 找出超過 1GB 的檔案並顯示大小
find / -size +1G -type f -exec du -h {} \; 2>/dev/null

# 找出空檔案並刪除
find /tmp -type f -empty -delete

# 找出大檔案並詢問是否刪除
find /var/log -size +100M -type f -ok rm {} \;

# 按大小範圍分類顯示
find . -type f -size +10M -size -100M -printf "%s %p\n" | sort -nr

依據時間搜尋

時間類型說明

# 時間類型
# mtime: 修改時間 (modify time)
# atime: 存取時間 (access time)  
# ctime: 狀態改變時間 (change time)

# 時間單位
# 預設單位: 天 (24小時)
# +n: n天之前
# -n: n天之內
# n:  恰好n天前

基本時間搜尋

# 修改時間搜尋
find . -mtime 3                     # 恰好 3 天前修改
find . -mtime -7                    # 7 天內修改
find . -mtime +30                   # 30 天前修改
find . -mtime +7 -mtime -30         # 7-30 天前修改

# 存取時間搜尋
find /home -atime -1                # 1 天內被存取
find /tmp -atime +7                 # 7 天以上未被存取

# 狀態改變時間
find . -ctime -1                    # 1 天內狀態改變

精確時間搜尋

# 分鐘為單位的時間搜尋
find /var/log -mmin -60             # 60 分鐘內修改
find . -amin +120                   # 120 分鐘前存取
find /tmp -cmin -30                 # 30 分鐘內狀態改變

# 比較檔案時間
find . -newer reference.txt         # 比 reference.txt 新的檔案
find . -cnewer backup.tar           # 狀態比 backup.tar 新

# 指定日期範圍
find /var/log -newermt "2023-01-01" ! -newermt "2023-12-31"

# 今天修改的檔案
find . -daystart -mtime 0

# 昨天修改的檔案
find . -daystart -mtime 1

依據權限搜尋

基本權限搜尋

# 精確權限匹配
find /home -perm 755                # 權限恰好是 755
find . -perm 644                    # 權限恰好是 644

# 包含指定權限
find /usr/bin -perm -755            # 至少有 755 權限
find . -perm -u+x                   # 擁有者有執行權限

# 任一符合權限
find /tmp -perm /222                # 任何人有寫入權限
find . -perm /u+w,g+w,o+w          # 任何人有寫入權限

# 可執行檔案
find /usr/local/bin -type f -executable
find . -type f -perm -u+x           # 擁有者可執行

進階權限搜尋

# 找出 SUID 檔案
find /usr -perm -4000 -type f 2>/dev/null

# 找出 SGID 檔案
find /usr -perm -2000 -type f 2>/dev/null

# 找出 sticky bit 目錄
find /tmp -perm -1000 -type d

# 找出可寫的檔案（安全檢查）
find /etc -type f -writable 2>/dev/null

# 找出無權限讀取的檔案
find /home -type f ! -readable 2>/dev/null

依據擁有者搜尋

基本擁有者搜尋

# 依據使用者搜尋
find /home -user john               # 屬於 john 的檔案
find /var -user root                # 屬於 root 的檔案
find . -user $(whoami)              # 屬於當前使用者的檔案

# 依據群組搜尋
find /home -group developers        # 屬於 developers 群組
find /var/www -group www-data       # 屬於 www-data 群組

# 依據 UID/GID 搜尋
find /home -uid 1000                # UID 為 1000 的檔案
find /var -gid 100                  # GID 為 100 的檔案

進階擁有者搜尋

# 找出無主檔案（孤兒檔案）
find /home -nouser                  # 沒有對應使用者的檔案
find /var -nogroup                  # 沒有對應群組的檔案

# 組合條件搜尋
find /home -user john -group staff  # 屬於 john 且群組是 staff
find /tmp -user root ! -group root  # 屬於 root 但群組不是 root

# 找出特定使用者的大檔案
find /home -user john -size +100M -type f

執行動作 (-exec 和 -ok)

基本 -exec 用法

# 基本語法：-exec command {} \;
# {} 代表找到的檔案
# \; 表示命令結束

# 刪除找到的檔案
find /tmp -name "*.tmp" -exec rm {} \;

# 複製檔案
find . -name "*.txt" -exec cp {} backup/ \;

# 移動檔案
find . -name "*.log" -exec mv {} /var/log/ \;

# 修改權限
find /var/www -type f -exec chmod 644 {} \;
find /var/www -type d -exec chmod 755 {} \;

進階 -exec 用法

# 使用 -exec {} + 提高效能（批次處理）
find . -name "*.txt" -exec grep "pattern" {} +
find /tmp -name "*.tmp" -exec rm {} +

# 執行複雜命令
find . -type f -name "*.sh" -exec sh -c 'echo "Processing: $1"; chmod +x "$1"' _ {} \;

# 在找到的目錄中執行命令
find /var/log -type d -exec sh -c 'echo "Directory: $1"; ls -la "$1"' _ {} \;

# 條件執行
find . -name "*.txt" -exec test -s {} \; -exec echo "Non-empty: {}" \;

互動式 -ok 用法

# -ok 會在執行前詢問確認
find /tmp -name "*.old" -ok rm {} \;

# 互動式移動檔案
find . -name "*.bak" -ok mv {} backup/ \;

# 互動式權限修改
find /home -name "*.sh" -ok chmod +x {} \;

邏輯運算符

基本邏輯運算

# AND 運算（預設）
find . -name "*.txt" -size +1M      # 名稱是 *.txt 且大小 > 1M
find . -type f -user john           # 是檔案且屬於 john

# OR 運算
find . \( -name "*.txt" -o -name "*.md" \)  # txt 或 md 檔案
find . -type f \( -name "*.log" -o -name "*.tmp" \)

# NOT 運算
find . -type f ! -name "*.txt"      # 不是 txt 的檔案
find . ! -path "*/.*"               # 排除隱藏目錄

複雜邏輯組合

# 複雜條件組合
find . \( -name "*.txt" -o -name "*.md" \) -a -size +1k -a ! -path "*/tmp/*"

# 多重排除條件
find /var/log \( ! -name "*.gz" ! -name "*.old" \) -type f -mtime -7

# 巢狀邏輯條件
find . \( \( -name "*.c" -o -name "*.h" \) -a -mtime -7 \) -o \( -name "*.py" -a -size +10k \)

輸出格式化

使用 -printf 格式化輸出

# 基本格式化
find . -type f -printf "%f\n"                    # 只顯示檔名
find . -type f -printf "%p\t%s\n"               # 路徑和大小
find . -type f -printf "%M %u %g %s %p\n"       # 權限、擁有者、群組、大小、路徑

# 時間格式化
find . -type f -printf "%TY-%Tm-%Td %TH:%TM %p\n"  # 修改時間和路徑
find . -type f -printf "%Ac %p\n"                   # 存取時間

# 大小格式化
find . -type f -printf "%10s %p\n" | sort -nr       # 按大小排序

格式化參數說明

# 常用格式化參數
# %p: 檔案路徑
# %f: 檔案名稱
# %s: 檔案大小（bytes）
# %M: 檔案權限
# %u: 擁有者名稱
# %g: 群組名稱
# %T: 時間相關（需配合時間格式）
# %h: 目錄路徑
# %d: 檔案深度

實戰應用場景

系統清理與維護

# 清理臨時檔案
find /tmp -type f -atime +7 -delete                # 刪除 7 天未存取的檔案
find /var/log -name "*.log" -size +100M -delete    # 刪除大日誌檔案

# 清理快取檔案
find ~/.cache -type f -atime +30 -delete           # 清理舊快取

# 備份前清理
find /backup -name "*.tar.gz" -mtime +30 -delete   # 刪除 30 天前的備份

檔案整理與歸檔

# 按日期歸檔檔案
find /data -type f -name "*.log" -mtime +1 -exec gzip {} \;

# 按大小分類檔案
find /home -type f -size +1G -exec ls -lh {} \;

# 移動舊檔案到歸檔目錄
find /project -type f -mtime +90 -exec mv {} /archive/ \;

安全檢查

# 檢查 SUID/SGID 檔案
find /usr -type f \( -perm -4000 -o -perm -2000 \) -exec ls -l {} \;

# 檢查可寫檔案
find /etc -type f -writable 2>/dev/null

# 檢查無主檔案
find /home -nouser -o -nogroup

# 檢查異常權限
find /var/www -type f ! -perm 644 -o -type d ! -perm 755

開發與除錯

# 搜尋程式碼
find . -name "*.java" -exec grep -l "className" {} \;

# 找出編譯產生的檔案
find . \( -name "*.class" -o -name "*.o" -o -name "*.pyc" \) -delete

# 統計不同類型檔案數量
find . -type f -name "*.java" | wc -l
find . -type f -name "*.py" -exec wc -l {} + | tail -1

# 檢查程式碼行數
find . -name "*.py" -exec wc -l {} + | sort -nr | head -10

監控與分析

# 找出最近修改的檔案
find /var/log -type f -mmin -60 -exec ls -lt {} \;

# 監控檔案系統變化
find /etc -newer /tmp/baseline -type f

# 分析磁碟使用
find /home -type f -printf "%s %p\n" | sort -nr | head -20

# 找出重複檔案（基於大小）
find /data -type f -printf "%s %p\n" | sort | uniq -d -w 10

效能優化技巧

提升搜尋效能

# 限制搜尋深度
find /usr -maxdepth 3 -name "*.conf"

# 排除不必要的目錄
find / -path /proc -prune -o -path /sys -prune -o -name "*.txt" -print

# 使用更具體的路徑
find /var/log -name "*.log"    # 好
find / -name "*.log"           # 較慢

# 將最具選擇性的條件放在前面
find . -name "*.txt" -size +1M  # 好
find . -size +1M -name "*.txt"  # 也可以，但順序影響效能

批次處理優化

# 使用 {} + 而非 {} \; 提升效能
find . -name "*.txt" -exec wc -l {} +     # 快
find . -name "*.txt" -exec wc -l {} \;    # 慢

# 使用管道處理大量結果
find /var/log -name "*.log" -print0 | xargs -0 grep "ERROR"

# 並行處理
find . -name "*.jpg" -print0 | xargs -0 -P 4 -I {} convert {} {}.thumb.jpg

常見錯誤與解決方案

權限錯誤處理

# 忽略權限錯誤
find /var -name "*.log" 2>/dev/null

# 只搜尋有權限的目錄
find /var -readable -name "*.log"

# 使用 sudo 搜尋受保護的目錄
sudo find /root -name "*.conf"

特殊字元處理

# 處理檔名中的空格
find . -name "* *" -print0 | xargs -0 ls -l

# 處理特殊字元
find . -name "file[1-3].txt"
find . -name "*.txt" -not -name "*\&*"

記憶體使用優化

# 避免一次載入過多結果
find /large_dir -name "*.txt" | head -100

# 使用 -quit 在找到第一個結果後停止
find . -name "target.txt" -quit

# 分段處理大目錄
find /huge_dir -maxdepth 1 -type d | while read dir; do
    find "$dir" -name "*.txt"
done

與其他工具組合

與 grep 組合

# 在檔案中搜尋內容
find . -name "*.txt" -exec grep -l "pattern" {} \;

# 搜尋並顯示匹配行
find . -name "*.log" -exec grep -Hn "ERROR" {} \;

# 使用 xargs 提升效能
find . -name "*.txt" | xargs grep "pattern"
find . -name "*.txt" -print0 | xargs -0 grep "pattern"

與 tar 組合

# 備份找到的檔案
find /home -name "*.doc" -print0 | tar -czf backup.tar.gz --null -T -

# 歸檔舊檔案
find /data -mtime +30 -print0 | tar -czf old_files.tar.gz --null -T -

與 rsync 組合

1
2

# 同步找到的檔案
find /source -name "*.txt" -print0 | rsync -av --files-from=- --from0 /source/ /destination/

macOS（BSD find）vs Linux（GNU find）

macOS 缺少的 GNU 功能

# GNU find only：-printf 自定義輸出格式
find . -name "*.java" -printf "%f\t%s bytes\n"  # macOS 不支援

# macOS 替代做法
find . -name "*.java" -exec ls -la {} \;

# GNU find only：-regextype 選擇正規表達式引擎
find . -regextype posix-extended -regex ".*\.(java|kt)"  # macOS 不支援 -regextype

# macOS 的 find -regex 只支援 Basic RE（BRE）
find . -regex ".*\.java"  # 可以，但無法用 ERE 的 +、?、|

效能提示

# 避免 fork exec：用 -print0 | xargs -0 比 -exec {} \; 快
find . -name "*.log" -print0 | xargs -0 rm

# -exec {} + (自動 batching) 比 -exec {} \; 少 fork 次數
find . -name "*.txt" -exec grep "pattern" {} +

總結

核心優勢

強大的搜尋能力：支援多種條件組合搜尋
批次操作：可對搜尋結果執行各種動作
高度可配置：豐富的參數和選項
跨平台相容：在各種 Unix-like 系統中一致

最佳實踐

明確搜尋範圍：使用具體的路徑而非根目錄
合理使用條件：將最具選擇性的條件放在前面
善用邏輯運算：合理組合 AND、OR、NOT 條件
注意效能：大目錄搜尋時考慮使用 -maxdepth 限制
安全操作：使用 -ok 而非 -exec 進行危險操作

常用技巧記憶

# 日常最常用的模式
find . -name "*.txt"                    # 基本檔名搜尋
find . -type f -size +100M              # 大檔案搜尋
find . -mtime -7                        # 最近修改檔案
find . -name "*.tmp" -delete            # 清理臨時檔案
find . -name "*.sh" -exec chmod +x {} \; # 批次修改權限

find 命令的強大之處在於其靈活性和可組合性。熟練掌握這個工具，能夠大幅提升 Linux 系統管理和日常工作的效率。記住：實務中最重要的是理解各種條件的組合邏輯，並根據實際需求選擇最適合的搜尋策略。

Shell 檔案與字串表達式詳解

Sat, 01 Oct 2022 21:25:56 +0800

概述

在撰寫 Shell Script 時，我們經常需要對檔案、目錄或字串的狀態進行判斷，例如檢查檔案是否存在、是否可讀，或判斷字串是否為空。這時就需要使用測試表達式 [ ... ] 或 test 指令。本文將詳細介紹這些常用的表達式及其用法。

檔案測試表達式

檔案測試表達式用於判斷檔案的類型或權限狀態。其回傳值為布林值（true 或 false），可搭配 if 條件式使用。

語法

1
2
3

if [ -<operator> <filename> ]; then
  # do something
fi

常用運算子

運算子	說明	範例
`-e`	如果檔案存在 (exist)，則為 `true`	`[ -e /etc/hosts ]`
`-d`	如果檔案是目錄 (directory)，則為 `true`	`[ -d /home/user ]`
`-f`	如果檔案是常規檔案 (regular file)，則為 `true`	`[ -f /etc/passwd ]`
`-L`	如果檔案是符號連結 (symbolic link)，則為 `true`	`[ -L /usr/bin/python ]`
`-h`	與 `-L` 相同，如果檔案是符號連結，則為 `true`	`[ -h /usr/bin/python ]`
`-r`	如果檔案可讀 (readable)，則為 `true`	`[ -r /etc/shadow ]`
`-w`	如果檔案可寫 (writable)，則為 `true`	`[ -w /tmp/test.log ]`
`-x`	如果檔案可執行 (executable)，則為 `true`	`[ -x ./deploy.sh ]`
`-s`	如果檔案大小不為 0，則為 `true`	`[ -s /var/log/syslog ]`

檔案比較運算子

用於比較兩個檔案的新舊關係。

cURL 完整指南：HTTP 客戶端工具與 API 測試利器

Tue, 03 Aug 2021 10:23:31 +0800

概述

cURL（Client URL）是一個功能強大的命令行工具和函式庫，用於傳輸各種網路協定的資料。它支援 HTTP、HTTPS、FTP、SFTP、TELNET 等多種協定，是開發者進行 API 測試、網路除錯和自動化腳本的必備工具。

核心特徵

多協定支援：HTTP/HTTPS、FTP、SFTP、SMTP、POP3 等
豐富的選項：支援各種 HTTP 方法、標頭、認證方式
跨平台：適用於 Linux、macOS、Windows 等系統
腳本友好：輸出格式化，適合自動化處理
安全性：支援 SSL/TLS、各種認證機制

安全注意事項

`-k` / `--insecure`：MITM 風險

curl -k https://example.com 跳過 TLS 憑證驗證，會讓你容易受到中間人攻擊（MITM）。

僅允許使用場景：

本機測試自簽憑證的開發環境
CI/CD 內部系統（確定網路是受信任的）

正確做法（而非跳過驗證）：

# 指定自訂 CA
curl --cacert /path/to/ca.crt https://internal-service/

# 或設定 SSL_CERT_FILE 環境變數
SSL_CERT_FILE=/path/to/ca-bundle.crt curl https://internal-service/

`--fail-with-body`（curl 7.76+）

比 --fail 更好的錯誤處理：--fail 在 HTTP 4xx/5xx 時靜默失敗，--fail-with-body 同樣在 4xx/5xx 時返回非 0 exit code，但同時顯示 response body（對排查錯誤有幫助）：

YAML 語法從入門到實踐

Tue, 29 Jun 2021 13:45:56 +0800

前言

在現代軟體開發中，設定檔是不可或缺的一環。從 Java 的 Spring Boot 框架 (Spring MVC 過往使用大量的 XML)，到我目前使用的 Hugo 靜態網站產生器，都能看到 .properties、.yml 或 .toml 等格式的身影。

雖然這些格式各有優勢，但在雲原生領域，特別是設定 Kubernetes (K8s) 資源時，YAML (YAML Ain’t Markup Language) 已成為事實上的標準。因此，掌握 YAML 的語法至關重要。

核心語法

YAML 的設計目標是易於人類閱讀和撰寫。它的語法主要基於縮排和幾個簡單的符號。

註解: 使用 # 號標示單行註解。
文件開頭: 使用三個連字號 --- 作為文件的開始符號 (選用)。

鍵值對 (Key-Value Pair)

YAML 的基本組成單位是鍵值對，格式為 key: value (注意冒號後面需要一個空格)。

`1`	`apiVersion: v1`

階層/物件 (Objects)

透過換行和縮排 (建議使用兩個空格) 來表示階層關係。這在 JSON 中相當於一個物件。

以下範例等同於 spring.datasource.username = "root"。

1
2
3

spring:
  datasource:
    username: root

陣列/列表 (Arrays/Lists)

陣列有兩種常見的表示方式：

Dig 命令完整指南：DNS 查詢與網路診斷的強大工具

Fri, 08 Jan 2021 21:39:14 +0800

概述

dig（Domain Information Groper）是一個功能強大的命令行 DNS 查詢工具，用於執行 DNS 查詢並顯示詳細的查詢結果。它是網路管理員、系統管理員和開發者進行 DNS 診斷、網路故障排除和域名解析分析的必備工具。

核心特徵

靈活的查詢選項：支援各種 DNS 記錄類型查詢
詳細的輸出資訊：提供完整的 DNS 響應詳情
多種輸出格式：支援簡潔、詳細和自訂格式
強大的診斷功能：追蹤查詢路徑和效能分析
腳本友好：適合自動化和批次處理

安裝與環境準備

各系統安裝方法

# Ubuntu/Debian
sudo apt-get install dnsutils

# CentOS/RHEL/Fedora
sudo yum install bind-utils          # CentOS 7 及以下
sudo dnf install bind-utils          # Fedora/CentOS 8+

# macOS (通常已預裝)
brew install bind

# 驗證安裝
dig -v

基本語法

`1`	`dig [@server] [domain] [type] [options]`

基本使用

簡單 DNS 查詢

# 基本查詢（A 記錄）
dig google.com

# 指定記錄類型
dig google.com A
dig google.com AAAA
dig google.com MX
dig google.com NS
dig google.com TXT

# 簡潔輸出
dig google.com +short

# 只顯示答案部分
dig google.com +noall +answer

查詢結果解析

標準 dig 輸出包含以下部分：

AWK 程式設計完整指南：Linux 文本處理與資料分析利器

Sat, 06 Apr 2019 23:18:56 +0800

概述

AWK 是一種強大的模式掃描和處理語言，由 Alfred Aho、Peter Weinberger 和 Brian Kernighan 於 1977 年在貝爾實驗室開發。AWK 特別適合處理結構化文本資料，能夠進行複雜的文本分析、報表生成和資料提取。

核心特徵

模式-動作程式設計：基於模式匹配執行相應動作
自動欄位分割：自動將輸入行分割為欄位
強大的內建變數：提供豐富的環境資訊
數學運算能力：支援完整的算術和字串操作
正規表達式支援：強大的模式匹配功能

相容性注意事項

macOS vs Linux 差異

macOS 內建的 awk 是 BSD awk（One True AWK），而 Linux 發行版通常是 GNU awk (gawk)。兩者差異：

功能	GNU awk (gawk)	BSD awk (macOS)
`gensub()`	支援	不支援
TCP/IP 連線 (`/inet/tcp`)	支援	不支援
`PROCINFO`	支援	不支援
`printf "%'d"` 千位分隔	支援	不支援
正規表達式 interval (`{n,m}`)	支援	不支援（需 –re-interval）

gawk-only 功能請明確標注，或提供替代寫法。macOS 用戶如需完整功能：brew install gawk。

Sed 流編輯器完整指南：Linux 文本處理的強大工具

Fri, 18 Jan 2019 10:23:31 +0800

概述

sed（Stream Editor，流編輯器）是 Unix/Linux 系統中功能強大的文本處理工具。它能夠對文本流進行非互動式的編輯操作，包括搜尋、替換、插入、刪除等功能。作為管道處理的重要工具，sed 在自動化腳本和批次文本處理中扮演關鍵角色。

核心特徵

流式處理：逐行處理文本，適合大檔案操作
非互動式：可在腳本中自動執行
正規表達式：支援強大的模式匹配
原地編輯：可直接修改原始檔案
管道友好：適合與其他命令組合使用

基本語法

1
2
3

sed [選項] '地址定界command' file(s)
sed [選項] -e 'script1' -e 'script2' file(s)
sed [選項] -f script.sed file(s)

常用選項

-n          # 安靜模式，不自動列印處理結果
-e script   # 指定要執行的腳本命令
-f file     # 從檔案讀取腳本命令
-i[suffix]  # 直接修改檔案（可選備份後綴）
-r 或 -E    # 使用擴展正規表達式
-s          # 將多個檔案視為獨立處理
--debug     # 偵錯模式，顯示執行過程

基本範例

# 基本文本替換
sed 's/old/new/' file.txt          # 替換每行第一個匹配
sed 's/old/new/g' file.txt         # 替換所有匹配
sed 's/old/new/2' file.txt         # 替換每行第二個匹配

# 直接修改檔案
sed -i 's/old/new/g' file.txt      # 直接修改原檔案
sed -i.bak 's/old/new/g' file.txt  # 修改前先備份

地址定界

地址定界用於指定 sed 命令作用的行範圍：