使用Go语言带你搞定图片压缩指南

go version

# Windows系统
go build -o 图片压缩.exe main.go

# Mac/Linux系统
go build -o 图片压缩 main.go

# Windows
图片压缩.exe <输入文件路径> <输出文件路径> <目标大小（KB）>

# Mac/Linux
./图片压缩 <输入文件路径> <输出文件路径> <目标大小（KB）>

# Windows
图片压缩.exe 学生照片.jpg 压缩后的照片.jpg 200

# Mac/Linux
./图片压缩 学生照片.jpg 压缩后的照片.jpg 200

package main

import (
	"bytes"
	"flag"
	"fmt"
	"image"
	"image/jpeg"
	"os"
	"path/filepath"
	"strconv"
)

// resizeNearest 使用最近邻插值算法缩放图像
// 最近邻插值是最简单的图像缩放算法，通过直接映射源图像像素来实现缩放
// 参数:
// - src: 源图像
// - newWidth: 目标宽度
// - newHeight: 目标高度
// 返回值:
// - *image.NRGBA: 缩放后的图像
func resizeNearest(src image.Image, newWidth, newHeight int) *image.NRGBA {
	// 获取源图像的边界和尺寸
	srcBounds := src.Bounds()
	srcW, srcH := srcBounds.Dx(), srcBounds.Dy()

	// 创建目标图像，使用NRGBA格式（无预乘alpha的RGBA）
	dst := image.NewNRGBA(image.Rect(0, 0, newWidth, newHeight))

	// 遍历目标图像的每个像素
	for y := 0; y < newHeight; y++ {
		for x := 0; x < newWidth; x++ {
			// 计算源图像中对应的坐标
			srcX := int(float64(x) * float64(srcW) / float64(newWidth))
			srcY := int(float64(y) * float64(srcH) / float64(newHeight))
			
			// 边界检查，确保不会越界
			if srcX >= srcW {
				srcX = srcW - 1
			}
			if srcY >= srcH {
				srcY = srcH - 1
			}
			
			// 将源图像像素颜色复制到目标图像
			dst.Set(x, y, src.At(srcX, srcY))
		}
	}
	return dst
}

// encodeJPEG 将图像编码为JPEG格式的字节数据
// 参数:
// - img: 要编码的图像
// - quality: JPEG压缩质量(1-100)，值越高质量越好
// 返回值:
// - []byte: 编码后的JPEG字节数据
func encodeJPEG(img image.Image, quality int) []byte {
	var buf bytes.Buffer
	// 使用Go标准库的jpeg.Encode函数进行编码
	jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality})
	return buf.Bytes()
}

// forceCompressToSize 强制将图像压缩到指定大小
// 使用两阶段压缩策略：先尝试调整质量，若不行再进行尺寸缩放
// 参数:
// - img: 原始图像
// - targetSize: 目标文件大小(字节)
// 返回值:
// - []byte: 压缩后的图像数据
// - error: 可能的错误信息
func forceCompressToSize(img image.Image, targetSize int64) ([]byte, error) {
	// 获取原始图像的尺寸
	originalBounds := img.Bounds()
	origW, origH := originalBounds.Dx(), originalBounds.Dy()

	// 阶段1：仅调整JPEG质量参数（不改变图像尺寸）
	// 从高质量开始尝试，逐步降低质量
	for q := 95; q >= 10; q -= 5 {
		data := encodeJPEG(img, q)
		// 如果当前质量下的文件大小已满足要求，直接返回
		if int64(len(data)) <= targetSize {
			return data, nil
		}
	}

	// 阶段2：如果仅调整质量无法达到目标大小，则使用二分法缩放图像尺寸
	lowScale, highScale := 0.25, 1.0 // 缩放比例范围 (25% - 100%)
	bestData := make([]byte, 0)       // 存储最佳压缩结果
	minDimension := 100               // 最小维度，防止图像被过度缩小
	const maxIterations = 100         // 最大迭代次数，避免死循环

	for i := 0; i < maxIterations; i++ {
		// 计算当前的缩放比例（二分法）
		scale := (lowScale + highScale) / 2
		// 计算新的图像尺寸
		newW := int(float64(origW) * scale)
		newH := int(float64(origH) * scale)

		// 确保图像不会小于最小尺寸
		if newW < minDimension || newH < minDimension {
			newW, newH = minDimension, minDimension
		}

		// 缩放图像并以固定质量(75)编码
		smallImg := resizeNearest(img, newW, newH)
		data := encodeJPEG(smallImg, 75)
		fileSize := int64(len(data))

		// 根据当前文件大小调整搜索范围
		if fileSize <= targetSize {
			// 如果符合要求，记录最佳结果并尝试更大的尺寸
			if len(bestData) == 0 || fileSize < int64(len(bestData)) {
				bestData = data
			}
			lowScale = scale // 尝试更大的尺寸
		} else {
			highScale = scale // 尝试更小的尺寸
		}

		// 当缩放比例的精度足够时退出循环
		if highScale-lowScale < 0.01 { // 1%的精度
			break
		}
	}

	// 如果找到合适的压缩结果，返回最佳数据
	if len(bestData) > 0 {
		return bestData, nil
	}

	// 最后兜底策略：如果没有找到合适的尺寸，则返回最小尺寸的图片
	finalImg := resizeNearest(img, minDimension, minDimension)
	return encodeJPEG(finalImg, 75), nil
}

func main() {
	// 解析命令行参数
	flag.Parse()
	args := flag.Args()

	// 检查参数数量是否正确
	if len(args) != 3 {
		fmt.Println("用法: go run main.go <输入文件路径> <输出文件路径> <目标大小（KB）>")
		fmt.Println("功能: 将输入图像压缩到指定大小，输出始终为JPEG格式")
		os.Exit(1)
	}
	
	// 提取参数值
	inFile := args[0]
	outFile := args[1]
	
	// 解析目标大小
	targetKB, err := strconv.ParseInt(args[2], 10, 64)
	if err != nil {
		fmt.Println("请提供有效的目标大小（KB）")
		os.Exit(1)
	}
	
	// 将KB转换为字节
	target := targetKB * 1024

	// 检查输入文件是否存在
	if _, err := os.Stat(inFile); os.IsNotExist(err) {
		fmt.Printf("错误: 输入文件 '%s' 不存在\n", inFile)
		os.Exit(1)
	}

	// 打开输入文件
	f, err := os.Open(inFile)
	if err != nil {
		fmt.Printf("错误: 无法打开输入文件: %v\n", err)
		os.Exit(1)
	}
	defer f.Close() // 确保在函数结束时关闭文件

	// 解码图像（支持多种格式）
	img, format, err := image.Decode(f)
	if err != nil {
		fmt.Printf("错误: 无法解码图像: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("成功读取 %s 格式图像\n", format)
	fmt.Printf("开始压缩，目标大小: %d 字节\n", target)

	// 执行压缩
	data, err := forceCompressToSize(img, target)
	if err != nil {
		fmt.Printf("错误: 压缩过程中出错: %v\n", err)
		os.Exit(1)
	}

	// 确保输出目录存在
	outDir := filepath.Dir(outFile)
	if outDir != "." {
		if err := os.MkdirAll(outDir, 0755); err != nil {
			fmt.Printf("错误: 无法创建输出目录: %v\n", err)
			os.Exit(1)
		}
	}

	// 写入压缩后的图像数据
	err = os.WriteFile(outFile, data, 0644)
	if err != nil {
		fmt.Printf("错误: 无法写入输出文件: %v\n", err)
		os.Exit(1)
	}
	
	// 输出压缩结果信息
	fmt.Printf("压缩完成!\n")
	fmt.Printf("最终大小: %d 字节 (目标: %d 字节)\n", len(data), target)
	fmt.Printf("压缩率: %.2f%%\n", float64(len(data))/float64(target)*100)
}