Golang 编写的图片压缩程序，质量、尺寸压缩，批量、单张压缩

目录：

　　前序

　　效果图

　　简介

　　全部代码

前序：

　　接触 golang 不久，一直是边学边做，边总结，深深感到这门语言的魅力，等下要跟大家分享是最近项目 服务端 用到的图片压缩程序，我单独分离了出来，做成了 exe 程序，可以在 Window 下运行。也可以放到 Linux 环境下编译运行，golang 是一种静态、跨平台的语言。

效果图

　　　　-

　　

压缩前　压缩后

开始main：

　　showTips 做了一些有好提示的文字输出，execute 是核心，压缩函数的调用也在里面

 func main() {
     showTips()
     execute()
     time.Sleep( * time.Minute) /** 如果不是自己点击退出，延时5分钟 */
 }

提示函数

　　我分离了两种压缩形式，批量和单张，再组合质量和尺寸，压缩100张600K的图片到8~9K，200px宽度，仅用了6秒左右，win 10，12G，i5，ssd。

　　还可以做完全的，宽和高像素尺寸的限制，只需要改变几个参数，大家先来看看程序运行的时候显示给用户的提示信息：

　　对于批量压缩，自动遍历用户输入的文件夹里面的所有符合格式的文件，并进行压缩。

 func showTips()  {
     tips := []string{
         "请输入文件夹或图片路径:",
         "如果输入文件夹,那么该目录的图片将会被批量压缩;",
         "如果是图片路径，那么将会被单独压缩处理。",
         "例如：",
         "C:/Users/lzq/Desktop/headImages/ 75 200",
         "指桌面 headImages 文件夹，里面的图片质量压缩到75%，宽分辨率为200，高是等比例计算",
         "C:/Users/lzq/Desktop/headImages/1.jpg 75 200",
         "指桌面的 headImages 文件夹里面的 1.jpg 图片,质量压缩到75%，宽分辨率为200，高是等比例计算 ",
         "请输入："}
     itemLen := len(tips)
     for i :=;i<itemLen;i++ {
         if i == itemLen - {
             fmt.Printf(tips[i])
         }else{
             fmt.Println(tips[i])
         }
     }
 }

压缩结构体：

　　这个比较简单，其余添加可以自定义

 type InputArgs struct {
     OutputPath string  /** 输出目录 */
     LocalPath  string  /** 输入的目录或文件路径 */
     Quality    int     /** 质量 */
     Width      int     /** 宽度尺寸，像素单位 */
 }

图片格式验证

　　自定义支持的文件格式，主要是图片的格式，同时拆分返回一些关键的信息，例如尾缀

 /** 是否是图片 */
 func isPictureFormat(path string) (string,string,string) {
     temp := strings.Split(path,".")
     if len(temp) <= {
         return "","",""
     }
     mapRule := make(map[string]int64)
     mapRule["jpg"]  =
     mapRule["png"]  =
     mapRule["jpeg"] =
     // fmt.Println(temp[1]+"---")
     /** 添加其他格式 */
     if mapRule[temp[]] ==   {
         println(temp[])
         return path,temp[],temp[]
     }else{
         return "","",""
     }
 }

文件夹遍历

　　主要用于批量压缩，做了所输入的目录的图片文件遍历，和要保存到的文件夹的创建，和采用纳秒级做压缩后的图片的名称。

 func getFilelist(path string) {
     /** 创建输出目录 */
     errC := os.MkdirAll(inputArgs.OutputPath, )
     if errC != nil {
         fmt.Printf("%s", errC)
         return
     }
     err := filepath.Walk(path, func(pathFound string, f os.FileInfo, err error) error {
         if ( f == nil ) {
             return err
         }
         if f.IsDir() { /** 是否是目录 */
             return nil
         }
         // println(pathFound)
         /** 找到一个文件 */
         /** 判断是不是图片 */
         localPath,format,_ := isPictureFormat(pathFound)
         /** 随机数 */
         t := time.Now()
         millis := t.Nanosecond() /** 纳秒 */
         outputPath := inputArgs.OutputPath+strconv.FormatInt(int64(millis),)+"."+format
         if localPath!="" {
             if !imageCompress(
                 func() (io.Reader,error){
                     return os.Open(localPath)
                 },
                 func() (*os.File,error) {
                     return os.Open(localPath)
                 },
                 outputPath,
                 inputArgs.Quality,
                 inputArgs.Width,format) {
                 fmt.Println("生成缩略图失败")
             }else{
                 fmt.Println("生成缩略图成功 "+outputPath)
             }
         }
         return nil
     })
     if err != nil {
         fmt.Printf("输入的路径信息有误 %v\n", err)
     }
 }

压缩前处理函数：

　　主要做了压缩结构体数据的配置，和验证用户路径的输入以及最终压缩输出文件目录的路径组合。这里有个坑点，对于控制台的数据获取，最好使用 bufio.NewReader(os.Stdin) 而不是 fmt.Scanf 否则，在fmt.p... 输出错误提示信息的时候也会被当作输入读取了，而不是用户输入的。

func execute()  {
    /** 获取输入 */
    //str := ""
    //fmt.Scanln (&str) /** 不要使用 scanf，它不会并以一个新行结束输入 */

    reader := bufio.NewReader(os.Stdin)
    data, _, _ := reader.ReadLine()
    /** 分割 */
    strPice := strings.Split(string(data)," ") /** 空格 */
    if len(strPice) <  {
        fmt.Printf("输入有误，参数数量不足,请重新输入或退出程序：")
        execute()
        return
    }

    inputArgs.LocalPath = strPice[]
    inputArgs.Quality,_ = strconv.Atoi(strPice[])
    inputArgs.Width,_   = strconv.Atoi(strPice[])

    pathTemp,format,top := isPictureFormat(inputArgs.LocalPath)
    if pathTemp == "" {
        /** 目录 */
        /** 如果输入目录，那么是批量 */
        fmt.Println("开始批量压缩...")
        rs := []rune(inputArgs.LocalPath)
        end := len(rs)
        substr := string(rs[end-:end])
        if substr=="/" {
            /** 有 / */
            rs := []rune(inputArgs.LocalPath)
            end := len(rs)
            substr := string(rs[:end-])
            endIndex := strings.LastIndex(substr,"/")
            inputArgs.OutputPath = string(rs[:endIndex])+"/LghImageCompress/";
        }else {
            endIndex := strings.LastIndex(inputArgs.LocalPath,"/")
            inputArgs.OutputPath = string(rs[:endIndex])+"/LghImageCompress/";
        }
        getFilelist(inputArgs.LocalPath)
    }else{
        /** 单个 */
        /** 如果输入文件，那么是单个，允许自定义路径 */
        fmt.Println("开始单张压缩...")
        inputArgs.OutputPath = top+"_compress."+format
        if !imageCompress(
            func() (io.Reader,error){
                return os.Open(inputArgs.LocalPath)
            },
            func() (*os.File,error) {
                return os.Open(inputArgs.LocalPath)
            },
            inputArgs.OutputPath,
            inputArgs.Quality,
            inputArgs.Width,format) {
            fmt.Println("生成缩略图失败")
        }else{
            fmt.Println("生成缩略图成功 "+inputArgs.OutputPath)
            finish()
        }
    }
}

压缩函数(核心)：

　　基于golang 1.7 自带的 image/jpeg 库。所谓的宽高完全自定义的修改，就在这里，我是采用了等比例缩放，所以只需要传入其中一项。里面分两次读写同一个文件是因为一次用于尺寸读取，而且两次是不能共用的，会出错。

 func imageCompress(
     getReadSizeFile func() (io.Reader,error),
     getDecodeFile func() (*os.File,error),
     to string,
     Quality,
     base int,
     format string) bool{
     /** 读取文件 */
     file_origin, err := getDecodeFile()
     defer file_origin.Close()
     if err != nil {
         fmt.Println("os.Open(file)错误");
         log.Fatal(err)
         return false
     }
     var origin image.Image
     var config image.Config
     var temp io.Reader
     /** 读取尺寸 */
     temp, err = getReadSizeFile()
     if err != nil {
         fmt.Println("os.Open(temp)");
         log.Fatal(err)
         return false
     }
     var typeImage int64
     format = strings.ToLower(format)
     /** jpg 格式 */
     if format=="jpg" || format =="jpeg" {
         typeImage =
         origin, err = jpeg.Decode(file_origin)
         if err != nil {
             fmt.Println("jpeg.Decode(file_origin)");
             log.Fatal(err)
             return false
         }
         temp, err = getReadSizeFile()
         if err != nil {
             fmt.Println("os.Open(temp)");
             log.Fatal(err)
             return false
         }
         config,err = jpeg.DecodeConfig(temp);
         if err != nil {
             fmt.Println("jpeg.DecodeConfig(temp)");
             return false
         }
     }else if format=="png" {
         typeImage =
         origin, err = png.Decode(file_origin)
         if err != nil {
             fmt.Println("png.Decode(file_origin)");
             log.Fatal(err)
             return false
         }
         temp, err = getReadSizeFile()
         if err != nil {
             fmt.Println("os.Open(temp)");
             log.Fatal(err)
             return false
         }
         config,err = png.DecodeConfig(temp);
         if err != nil {
             fmt.Println("png.DecodeConfig(temp)");
             return false
         }
     }
     /** 做等比缩放 */
     width  := uint(base) /** 基准 */
     height := uint(base*config.Height/config.Width)

     canvas := resize.Thumbnail(width, height, origin, resize.Lanczos3)
     file_out, err := os.Create(to)
     defer file_out.Close()
     if err != nil {
         log.Fatal(err)
         return false
     }
     if typeImage== {
         err = png.Encode(file_out, canvas)
         if err!=nil {
             fmt.Println("压缩图片失败");
             return false
         }
     }else{
         err = jpeg.Encode(file_out, canvas, &jpeg.Options{Quality})
         if err!=nil {
             fmt.Println("压缩图片失败");
             return false
         }
     }

     return true
 }

全部代码

　　gitHub： https://github.com/af913337456/golang_image_compress