Linux compress命令

历史说明：compress是Unix系统中一个经典的压缩工具，使用LZW（Lempel-Ziv-Welch）算法。它曾经是Unix系统的标准压缩工具，但现在已被gzip、bzip2等更高效的压缩工具所取代。compress主要用于处理旧的.Z格式压缩文件。
功能说明：compress命令使用LZW算法压缩文件，生成扩展名为.Z的压缩文件。它可以显著减少文本文件的大小，是Unix系统中历史悠久的压缩工具之一。
主要功能
  • 使用LZW算法压缩文件
  • 生成.Z格式压缩文件
  • 解压缩.Z文件（通过uncompress）
  • 控制压缩比（bits参数）
  • 保留原始文件（可选）
  • 递归压缩目录
注意事项
  • Z格式是Unix传统格式，现代系统较少使用
  • LZW算法有专利问题（已过期）
  • 压缩率通常不如gzip和bzip2
  • 最大支持16位压缩（bits参数）
  • 某些Linux发行版需要单独安装
  • 主要用于兼容旧的系统

命令语法

语法格式
compress [选项] [文件...]

命令参数

参数 说明
-b bits 指定压缩时使用的最大位数（9-16，默认16）
-c 将压缩结果输出到标准输出，不修改原文件
-d 解压缩文件（等同于uncompress命令）
-f 强制覆盖已存在的输出文件
-l 列出每个文件的压缩统计信息
-r 递归处理目录及其子目录
-v 显示详细处理信息
-V 显示版本信息
-C 产生与BSD compress兼容的输出
-q 安静模式，不显示警告信息

使用示例

1. 基本压缩操作 常用
示例
# 压缩单个文件
compress file.txt
# 生成：file.txt.Z，原文件被删除

# 压缩多个文件
compress file1.txt file2.txt file3.txt
# 生成：file1.txt.Z file2.txt.Z file3.txt.Z

# 压缩并保留原始文件
compress -c file.txt > file.txt.Z
# 或
cat file.txt | compress > file.txt.Z

# 压缩整个目录（需要-r参数）
compress -r directory/

# 使用不同的bits值压缩
compress -b 12 file.txt  # 使用12位压缩
compress -b 9 file.txt   # 使用9位压缩（最小）
2. 查看压缩信息
# 查看压缩统计信息
compress -l file.txt.Z
# 输出示例：
# Compression of file.txt:
# -- using 16 bits
# 10240 bytes -> 5678 bytes (55.4% compression)

# 查看多个文件的压缩信息
compress -l *.Z

# 详细模式查看压缩信息
compress -lv file.txt.Z
# 输出示例：
# file.txt: -- replaced with file.txt.Z
# Compression: 55.4% -- using 16 bits

# 查看压缩文件的原始大小
ls -l file.txt.Z
wc -c file.txt  # 原始文件大小
compress -l file.txt.Z | awk '{print $1}'  # 压缩后大小
3. 解压缩操作
# 解压缩.Z文件
uncompress file.txt.Z
# 或
compress -d file.txt.Z
# 生成：file.txt，原.Z文件被删除

# 解压缩到标准输出
uncompress -c file.txt.Z
# 或
compress -dc file.txt.Z

# 解压缩多个文件
uncompress file1.Z file2.Z file3.Z

# 解压缩并保留原压缩文件
uncompress -c file.Z > file.txt

# 强制解压缩（覆盖已存在文件）
uncompress -f file.Z
4. 标准输入输出操作
# 从标准输入读取并压缩
echo "Hello World" | compress > hello.Z

# 从标准输入读取并解压缩
cat hello.Z | uncompress

# 压缩管道数据
cat largefile.txt | compress > largefile.txt.Z

# 解压缩管道数据
cat data.Z | uncompress > data.txt

# 压缩并传输
compress -c data.txt | ssh user@host "cat > /tmp/data.txt.Z"

# 接收并解压缩
ssh user@host "cat /tmp/data.txt.Z" | uncompress > data.txt
5. 递归操作目录
# 递归压缩目录下的所有文件
compress -r /path/to/directory

# 递归解压缩目录下的所有.Z文件
uncompress -r /path/to/directory

# 递归压缩并显示详细信息
compress -rv /path/to/directory

# 递归压缩特定类型的文件
find . -name "*.txt" -exec compress {} \;

# 递归解压缩特定目录
find /path -name "*.Z" -exec uncompress {} \;
6. 高级用法示例
# 创建与BSD兼容的压缩文件
compress -C file.txt

# 安静模式压缩
compress -q file.txt

# 压缩时测试文件完整性
compress file.txt && uncompress -t file.txt.Z

# 批量压缩并生成压缩报告
for file in *.txt; do
    echo "压缩: $file"
    compress -v "$file"
    echo ""
done

# 比较不同bits值的压缩效果
for bits in {9..16}; do
    cp test.txt test.txt.backup
    compress -b $bits test.txt
    size=$(stat -c%s test.txt.Z)
    uncompress test.txt.Z
    echo "Bits: $bits, 压缩后大小: $size"
done
rm -f test.txt.backup
7. 实际工作场景
# 场景1：备份旧日志文件
# 压缩一个月前的日志文件
find /var/log -name "*.log" -mtime +30 -exec compress {} \;

# 场景2：传输压缩文件
compress -c data.txt | ssh user@remote "cat > /tmp/data.txt.Z"
# 在远程服务器解压
ssh user@remote "uncompress -c /tmp/data.txt.Z > /tmp/data.txt"

# 场景3：批量处理旧压缩文件
# 将目录下所有.Z文件转换为.gz格式
for zfile in *.Z; do
    if [ -f "$zfile" ]; then
        basename="${zfile%.Z}"
        uncompress -c "$zfile" | gzip > "${basename}.gz"
        echo "转换: $zfile -> ${basename}.gz"
    fi
done

# 场景4：自动化压缩脚本
#!/bin/bash
# 自动压缩备份脚本
BACKUP_DIR="/backup/compress"
DATE=$(date +%Y%m%d)

mkdir -p "$BACKUP_DIR"
find /important/data -type f -name "*.txt" | while read file; do
    compress -c "$file" > "$BACKUP_DIR/$(basename "$file")_${DATE}.Z"
done

LZW算法详解

LZW（Lempel-Ziv-Welch）压缩算法

LZW算法是Abraham Lempel、Jacob Ziv和Terry Welch共同发明的一种无损数据压缩算法。

算法特点：
  • 字典编码：使用字典（查找表）替换重复出现的字符串
  • 自适应：字典在压缩过程中动态构建
  • 无预定义字典：编码器和解码器从空字典开始
  • 专利问题：历史上曾有专利限制，现已过期
压缩过程：
  1. 初始化字典包含所有单字符
  2. 查找输入中最长的已知字符串
  3. 输出该字符串的字典索引
  4. 将字符串加上下一个字符加入字典
  5. 重复直到处理完所有输入
LZW算法示例
# 示例：压缩字符串 "TOBEORNOTTOBEORTOBEORNOT"
# 初始化字典：T=0, O=1, B=2, E=3, R=4, N=5, O=6, T=7
# 注意：实际实现中字符用ASCII值表示

# 压缩过程：
# 输入     输出    新增字典项
# T
# TO       T      TO:8
# OB       O      OB:9
# BE       B      BE:10
# EO       E      EO:11
# OR       O      OR:12
# RN       R      RN:13
# NO       N      NO:14
# OT       O      OT:15
# TT       T      TT:16
# TOB      TO(8)  TOB:17
# BEO      BE(10) BEO:18
# ORT      OR(12) ORT:19
# TOBE     TOB(17) TOBE:20
# EOR      EO(11) EOR:21
# RNO      RN(13) RNO:22
# OT       OT(15) (已存在)
# (结束)

# 最终输出：T O B E O R N O T 8 10 12 17 11 13 15
# 原始：25字节 → 压缩后：15个编码（每个编码可小于1字节）

与其他压缩工具对比

工具 格式 算法 压缩率 速度 流行时期 当前状态
compress .Z LZW 中等 快 1980s-1990s 过时/遗留
gzip .gz DEFLATE 好 快 1990s-现在 广泛使用
bzip2 .bz2 Burrows-Wheeler 很好 中等 1990s-现在 常用
xz .xz LZMA2 优秀 慢 2000s-现在 现代标准
zip .zip DEFLATE等 中等 快 1980s-现在 跨平台标准
zstd .zst Zstandard 可调 极快 2010s-现在 新兴
压缩性能测试示例
#!/bin/bash
# 压缩工具性能比较测试

TEST_FILE="test_data.txt"
TEST_SIZE="10M"

echo "创建测试文件 ($TEST_SIZE)..."
# 创建包含随机文本的测试文件
base64 /dev/urandom | head -c $TEST_SIZE > "$TEST_FILE"

echo -e "\n=== 压缩性能测试 ==="
echo "工具        压缩后大小  压缩率   时间"

# compress测试
if command -v compress &> /dev/null; then
    echo -n "compress    "
    cp "$TEST_FILE" test.tmp
    time compress -f test.tmp 2>&1 | grep real | awk '{printf "%8s  ", $2}'
    comp_size=$(stat -c%s test.tmp.Z 2>/dev/null || echo 0)
    ratio=$(echo "scale=1; ($comp_size * 100) / $TEST_SIZE" | bc 2>/dev/null || echo 0)
    echo "$(numfmt --to=iec $comp_size)  ${ratio}%"
    rm -f test.tmp test.tmp.Z
fi

# gzip测试
echo -n "gzip        "
cp "$TEST_FILE" test.tmp
time gzip -f test.tmp 2>&1 | grep real | awk '{printf "%8s  ", $2}'
comp_size=$(stat -c%s test.tmp.gz 2>/dev/null || echo 0)
ratio=$(echo "scale=1; ($comp_size * 100) / $TEST_SIZE" | bc 2>/dev/null || echo 0)
echo "$(numfmt --to=iec $comp_size)  ${ratio}%"
rm -f test.tmp test.tmp.gz

# bzip2测试
echo -n "bzip2       "
cp "$TEST_FILE" test.tmp
time bzip2 -f test.tmp 2>&1 | grep real | awk '{printf "%8s  ", $2}'
comp_size=$(stat -c%s test.tmp.bz2 2>/dev/null || echo 0)
ratio=$(echo "scale=1; ($comp_size * 100) / $TEST_SIZE" | bc 2>/dev/null || echo 0)
echo "$(numfmt --to=iec $comp_size)  ${ratio}%"
rm -f test.tmp test.tmp.bz2

# 清理
rm -f "$TEST_FILE"
echo -e "\n测试完成"

实际应用脚本

脚本1：批量转换.Z文件为.gz格式
#!/bin/bash
# 批量将.Z文件转换为.gz格式

SOURCE_DIR="$1"
TARGET_DIR="$2"
KEEP_ORIGINAL=true  # 是否保留原始.Z文件

# 默认使用当前目录
if [ -z "$SOURCE_DIR" ]; then
    SOURCE_DIR="."
fi

if [ -z "$TARGET_DIR" ]; then
    TARGET_DIR="converted"
fi

# 创建目标目录
mkdir -p "$TARGET_DIR"

echo "=== .Z 到 .gz 格式转换工具 ==="
echo "源目录: $SOURCE_DIR"
echo "目标目录: $TARGET_DIR"
echo "保留原始文件: $KEEP_ORIGINAL"
echo "开始时间: $(date)"
echo ""

# 检查必要工具
check_command() {
    if ! command -v "$1" >/dev/null 2>&1; then
        echo "错误: 未找到 $1 命令"
        return 1
    fi
    return 0
}

if ! check_command "uncompress"; then
    echo "请安装 compress 工具包（包含uncompress）"
    exit 1
fi

if ! check_command "gzip"; then
    echo "请安装 gzip"
    exit 1
fi

# 转换统计
total_files=0
converted=0
failed=0

# 查找并转换.Z文件
find "$SOURCE_DIR" -type f -name "*.Z" -o -name "*.z" | while read z_file; do
    total_files=$((total_files + 1))

    filename=$(basename "$z_file")
    dirpath=$(dirname "$z_file")
    relative_path="${dirpath#$SOURCE_DIR}"
    relative_path="${relative_path#/}"

    # 创建目标子目录
    target_subdir="$TARGET_DIR"
    if [ -n "$relative_path" ]; then
        target_subdir="$TARGET_DIR/$relative_path"
        mkdir -p "$target_subdir"
    fi

    # 生成目标文件名（.Z替换为.gz）
    if [[ "$filename" =~ \.Z$ ]]; then
        gz_filename="${filename%.Z}.gz"
    elif [[ "$filename" =~ \.z$ ]]; then
        gz_filename="${filename%.z}.gz"
    else
        gz_filename="$filename.gz"
    fi

    target_file="$target_subdir/$gz_filename"

    echo "处理 ($total_files): $filename"

    # 检查.Z文件是否完整
    echo -n "  测试压缩文件..."
    if uncompress -t "$z_file" >/dev/null 2>&1; then
        echo "✓ 完整"
    else
        echo "✗ 损坏"
        failed=$((failed + 1))
        continue
    fi

    # 解压缩到临时文件
    temp_file=$(mktemp)
    echo -n "  解压缩..."
    if uncompress -c "$z_file" > "$temp_file" 2>/dev/null; then
        echo "✓ 完成"
    else
        echo "✗ 失败"
        failed=$((failed + 1))
        rm -f "$temp_file"
        continue
    fi

    # 使用gzip压缩
    echo -n "  gzip压缩..."
    if gzip -c "$temp_file" > "$target_file" 2>/dev/null; then
        echo "✓ 完成"

        # 验证gzip文件
        if gzip -t "$target_file" >/dev/null 2>&1; then
            # 计算压缩率
            z_size=$(stat -c%s "$z_file" 2>/dev/null || echo 0)
            gz_size=$(stat -c%s "$target_file" 2>/dev/null || echo 0)

            if [ "$z_size" -gt 0 ]; then
                ratio=$(echo "scale=1; ($gz_size * 100) / $z_size" | bc 2>/dev/null || echo 0)
                echo "  原始.Z: $(numfmt --to=iec $z_size)"
                echo "  新.gz: $(numfmt --to=iec $gz_size)"
                echo "  大小比: ${ratio}%"
            fi

            converted=$((converted + 1))
        else
            echo "  ✗ gzip文件验证失败"
            rm -f "$target_file"
            failed=$((failed + 1))
        fi
    else
        echo "✗ 压缩失败"
        failed=$((failed + 1))
    fi

    # 清理临时文件
    rm -f "$temp_file"

    # 可选：删除原始.Z文件
    if [ "$KEEP_ORIGINAL" = false ]; then
        echo "  删除原始文件"
        rm -f "$z_file"
    fi

    echo ""
done

# 显示统计信息
echo "=== 转换完成 ==="
echo "总文件数: $total_files"
echo "成功转换: $converted"
echo "转换失败: $failed"
echo "目标目录: $TARGET_DIR"
echo ""

# 显示磁盘使用情况
if [ "$converted" -gt 0 ]; then
    echo "磁盘使用统计:"
    du -sh "$TARGET_DIR"
fi
脚本2：compress/uncompress兼容性检查工具
#!/bin/bash
# compress/uncompress兼容性检查工具

echo "=== compress/uncompress兼容性检查 ==="
echo "检查时间: $(date)"
echo ""

# 检查命令是否存在
check_command() {
    local cmd="$1"
    local desc="$2"

    echo -n "检查 $desc ($cmd)... "
    if command -v "$cmd" >/dev/null 2>&1; then
        echo "✓ 已安装"

        # 显示版本信息
        if [ "$cmd" = "compress" ] || [ "$cmd" = "uncompress" ]; then
            version_output=$("$cmd" -V 2>&1 | head -1)
            echo "  版本: $version_output"
        fi

        return 0
    else
        echo "✗ 未安装"
        return 1
    fi
}

# 检查compress
check_command "compress" "compress命令"

# 检查uncompress
check_command "uncompress" "uncompress命令"

# 检查gzip（作为替代方案）
check_command "gzip" "gzip命令"

# 检查bzip2
check_command "bzip2" "bzip2命令"

echo ""
echo "=== 功能测试 ==="

# 创建测试文件
TEST_FILE="compress_test.txt"
TEST_CONTENT="This is a test file for compress/uncompress compatibility check. "
# 创建大一点的测试内容
for i in {1..100}; do
    echo "$TEST_CONTENT $i" >> "$TEST_FILE"
done

echo -n "1. 测试compress压缩... "
if compress -c "$TEST_FILE" > test.Z 2>/dev/null; then
    echo "✓ 成功"

    echo -n "2. 测试uncompress解压... "
    if uncompress -c test.Z > test.out 2>/dev/null; then
        echo "✓ 成功"

        echo -n "3. 测试文件完整性... "
        if cmp -s "$TEST_FILE" test.out; then
            echo "✓ 完整"
        else
            echo "✗ 文件损坏"
        fi
    else
        echo "✗ 失败"
    fi
else
    echo "✗ 失败"
fi

# 测试bits参数
echo -n "4. 测试bits参数(12 bits)... "
if compress -b 12 -c "$TEST_FILE" > test12.Z 2>/dev/null; then
    echo "✓ 成功"

    echo -n "5. 测试bits参数(9 bits)... "
    if compress -b 9 -c "$TEST_FILE" > test9.Z 2>/dev/null; then
        echo "✓ 成功"
    else
        echo "✗ 失败"
    fi
else
    echo "✗ 失败"
fi

# 测试递归压缩
echo -n "6. 测试递归压缩... "
mkdir -p test_dir/subdir
cp "$TEST_FILE" test_dir/
cp "$TEST_FILE" test_dir/subdir/
if compress -r test_dir 2>/dev/null; then
    echo "✓ 成功"
else
    echo "✗ 失败"
fi

# 清理测试文件
rm -rf "$TEST_FILE" test.Z test.out test12.Z test9.Z test_dir
echo ""
echo "=== 检查完成 ==="
echo ""
echo "建议："
echo "1. 如果需要处理.Z文件，确保compress/uncompress已安装"
echo "2. 对于新项目，建议使用gzip或bzip2代替compress"
echo "3. 可以使用脚本1将.Z文件批量转换为.gz格式"
脚本3：自动备份并使用compress压缩
#!/bin/bash
# 使用compress进行自动备份

# 配置
BACKUP_SOURCES=(
    "/etc"
    "/home/user/documents"
    "/var/www/html"
)
BACKUP_DIR="/backup/compress"
RETENTION_DAYS=30
COMPRESS_BITS=16  # compress使用的bits数
DATE_FORMAT="%Y%m%d_%H%M%S"
CURRENT_DATE=$(date +"$DATE_FORMAT")

# 创建备份目录
mkdir -p "$BACKUP_DIR"

echo "=== compress自动备份工具 ==="
echo "开始时间: $(date)"
echo "备份目录: $BACKUP_DIR"
echo "保留天数: $RETENTION_DAYS"
echo ""

# 日志函数
log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1"
}

# 检查compress是否可用
if ! command -v compress >/dev/null 2>&1; then
    log "错误: compress命令未安装"
    log "请安装: sudo apt install ncompress  # Debian/Ubuntu"
    log "       sudo yum install ncompress  # RHEL/CentOS"
    exit 1
fi

# 检查tar是否可用
if ! command -v tar >/dev/null 2>&1; then
    log "错误: tar命令未安装"
    exit 1
fi

# 备份统计
total_backups=0
success_backups=0
failed_backups=0

# 执行备份
for source in "${BACKUP_SOURCES[@]}"; do
    if [ ! -e "$source" ]; then
        log "警告: 源路径不存在 - $source"
        continue
    fi

    # 生成备份文件名
    source_name=$(basename "$source")
    if [ -z "$source_name" ]; then
        source_name="root"
    fi

    backup_name="${source_name}_${CURRENT_DATE}"
    tar_file="$BACKUP_DIR/${backup_name}.tar"
    compress_file="$BACKUP_DIR/${backup_name}.tar.Z"

    log "备份: $source"

    # 创建tar归档
    log "  创建tar归档..."
    if tar -cf "$tar_file" -C "$(dirname "$source")" "$(basename "$source")" 2>/dev/null; then
        tar_size=$(stat -c%s "$tar_file" 2>/dev/null || echo 0)
        log "  ✓ 完成 ($(numfmt --to=iec $tar_size))"
    else
        log "  ✗ 创建tar失败"
        failed_backups=$((failed_backups + 1))
        rm -f "$tar_file" 2>/dev/null
        continue
    fi

    # 使用compress压缩
    log "  使用compress压缩 (bits: $COMPRESS_BITS)..."
    if compress -b $COMPRESS_BITS -c "$tar_file" > "$compress_file" 2>/dev/null; then
        compress_size=$(stat -c%s "$compress_file" 2>/dev/null || echo 0)

        if [ "$tar_size" -gt 0 ]; then
            ratio=$(echo "scale=1; ($compress_size * 100) / $tar_size" | bc 2>/dev/null || echo 0)
            log "  ✓ 完成 ($(numfmt --to=iec $compress_size), 压缩比: ${ratio}%)"
        else
            log "  ✓ 完成 ($(numfmt --to=iec $compress_size))"
        fi

        # 测试压缩文件完整性
        log "  测试压缩文件..."
        if compress -t "$compress_file" 2>/dev/null; then
            log "  ✓ 文件完整"
            success_backups=$((success_backups + 1))
        else
            log "  ✗ 文件损坏"
            failed_backups=$((failed_backups + 1))
            rm -f "$compress_file" 2>/dev/null
        fi

        # 删除tar文件
        rm -f "$tar_file"
    else
        log "  ✗ compress压缩失败"
        failed_backups=$((failed_backups + 1))
        rm -f "$tar_file" "$compress_file" 2>/dev/null
    fi

    total_backups=$((total_backups + 1))
    echo ""
done

# 清理旧备份
log "清理超过${RETENTION_DAYS}天的备份..."
find "$BACKUP_DIR" -name "*.tar.Z" -type f -mtime +$RETENTION_DAYS -delete
deleted_count=$(find "$BACKUP_DIR" -name "*.tar.Z" -type f -mtime +$RETENTION_DAYS | wc -l)
log "删除 $deleted_count 个旧备份"

# 显示统计信息
echo ""
log "=== 备份完成 ==="
log "总备份任务: $total_backups"
log "成功备份: $success_backups"
log "失败备份: $failed_backups"
log ""
log "当前备份文件:"
find "$BACKUP_DIR" -name "*.tar.Z" -type f -exec ls -lh {} \; | head -10
log ""
log "备份目录大小:"
du -sh "$BACKUP_DIR"

注意事项

重要注意事项：
  • 过时技术：compress使用LZW算法，这是过时的压缩技术
  • 专利问题：LZW算法历史上受专利保护，现已过期
  • 安装需求：在一些现代Linux发行版中，compress需要单独安装（通常包名为ncompress）
  • 文件删除：默认compress会删除原始文件，使用-c参数可保留
  • 压缩比限制：最大支持16位压缩，压缩率通常不如现代工具
  • 编码问题：处理非ASCII文件名时可能有问题
  • 替代方案：建议使用gzip、bzip2或xz等现代压缩工具
  • 兼容性：主要用于处理旧的.Z格式文件，新项目不建议使用

常见问题

A: 主要区别：
对比项 compress gzip
算法 LZW DEFLATE (LZ77 + 霍夫曼编码)
格式 .Z .gz
压缩率 中等 更好
速度 快 快
流行时期 1980s-1990s 1990s-现在
专利状态 曾受专利保护（已过期） 免费开放
推荐度 不推荐（遗留系统） 推荐
使用建议： 
# 处理旧的.Z文件 -> 使用uncompress
uncompress file.Z

# 创建新压缩文件 -> 使用gzip
gzip file.txt

# 查看压缩文件 -> 使用对应的工具
zcat file.gz      # 查看.gz文件
uncompress -c file.Z  # 查看.Z文件

# 转换.Z为.gz
uncompress -c oldfile.Z | gzip > newfile.gz

A: 在大多数Linux发行版中，compress/uncompress包含在ncompress包中：
  • Debian/Ubuntu: sudo apt install ncompress
  • RHEL/CentOS: sudo yum install ncompress
  • Fedora: sudo dnf install ncompress
  • Arch Linux: sudo pacman -S ncompress
  • openSUSE: sudo zypper install ncompress
  • 从源码安装:
# 下载源码
wget http://example.com/ncompress-*.tar.gz
tar -xzf ncompress-*.tar.gz
cd ncompress-*
./configure
make
sudo make install

# 验证安装
which compress
which uncompress
compress -V
uncompress -V

# 检查包信息（Debian/Ubuntu）
dpkg -l | grep ncompress

# 检查包信息（RHEL/CentOS）
rpm -qa | grep ncompress

# 如果找不到包，可以尝试搜索
apt search ncompress      # Debian/Ubuntu
yum search ncompress      # RHEL/CentOS
dnf search ncompress      # Fedora

注意：在一些极简的Linux发行版或容器镜像中，可能需要添加软件源或从源码编译。

A: bits参数指定LZW算法使用的编码位数：
  • 范围：9-16位（默认16位）
  • 作用：控制压缩字典的大小和压缩率
  • bits值越大：字典越大，压缩率可能更高，但内存使用更多
  • bits值越小：字典越小，压缩率较低，但内存使用少
  • 默认16位：最多支持65536个字典条目
bits参数对压缩的影响： 
# 测试不同bits值的压缩效果
TEST_FILE="test_large.txt"
# 创建测试文件
for i in {1..1000}; do
    echo "This is test line $i with some repeated patterns." >> "$TEST_FILE"
done

echo "测试不同bits值的压缩效果:"
echo "Bits  压缩后大小  压缩率"
echo "----  ----------  ------"

for bits in 9 10 11 12 13 14 15 16; do
    # 压缩
    compress -b $bits -c "$TEST_FILE" > "test_${bits}bits.Z" 2>/dev/null

    # 计算大小和压缩率
    original_size=$(stat -c%s "$TEST_FILE")
    compressed_size=$(stat -c%s "test_${bits}bits.Z")
    ratio=$(echo "scale=1; ($compressed_size * 100) / $original_size" | bc 2>/dev/null || echo 0)

    printf "%-4d  %-10s  %-6s\n" $bits "$(numfmt --to=iec $compressed_size)" "${ratio}%"

    # 清理
    rm -f "test_${bits}bits.Z"
done

# 清理测试文件
rm -f "$TEST_FILE"

# 输出示例：
# Bits  压缩后大小  压缩率
# ----  ----------  ------
# 9     45K         45.0%
# 10    40K         40.0%
# 11    38K         38.0%
# 12    36K         36.0%
# 13    35K         35.0%
# 14    34K         34.0%
# 15    33K         33.0%
# 16    33K         33.0%

建议：对于一般用途，使用默认的16位即可。只有在内存受限的环境中才考虑使用较小的bits值。

相关命令

uncompress

解压缩.Z文件：

uncompress file.Z
uncompress -c file.Z
uncompress -f file.Z
uncompress -r directory/
gzip

现代压缩工具（推荐）：

gzip file.txt
gunzip file.gz
zcat file.gz
gzip -d file.gz
bzip2

高压缩率工具：

bzip2 file.txt
bunzip2 file.bz2
bzcat file.bz2
bzip2 -d file.bz2
7z

多格式压缩工具：

7z a archive.7z files/
7z x archive.7z
7z l archive.7z
7z x archive.Z  # 支持.Z格式
上一章: unarj 命令 下一章: cpio 命令