日期: 2021/08/18 天气：晴

    参考地址

    1. /*
    2.  * @Description: 多张图片上传压缩
    3.  * @Author: 惜神
    4.  * @Date: 2021-08-17 16:45:27
    5.  */
    7. const fs = require("fs");
    8. const JSZip = require("jszip"); 
    9. const image = require("imageinfo"); 
    10. const zip = new JSZip();
    11. const request = require('request');
    12. const path = require('path');
    13. const QRCode = require('qrcode');
    16. /**
    17.  * 创建新的文件夹用于保存图片（如果有自己的文件夹，可以不使用）
    18.  * @author: 惜神
    19.  * @param {String} dirname 创建文件路径
    20.  * @Date: 2021-08-17 17:36:07
    21.  */
    22. const mkdirSync = (dirname) => {
    23.     if (fs.existsSync(dirname)) {
    24.         return true;
    25.     } else {
    26.         if (mkdirSync(path.dirname(dirname))) {
    27.             fs.mkdirSync(dirname);
    28.             return true;
    29.         }
    30.     }
    31.     return false
    32. }
    34. /**
    35.  * @author: 惜神
    36.  * @param {String} folderPaths 压缩文件路径
    37.  * @param {String} outPath 压缩文件输出路径
    38.  * @Date: 2021-08-17 17:35:13
    39.  */
    40. const packZipList = (folderPaths, outPath) => {
    41.     const lists = getFiles.getFileList(folderPaths); //获取文件夹里的所有图片文件值
    42.     for (let i = 0; i < lists.length; i++) {
    43.         const data = fs.readFileSync(`${folderPaths}${lists[i].filename}`);
    44.         const suffix = lists[i].filename.split('.')[1];
    45.         zip.file(`photo_${i}.${suffix}`, data, { base64: true });
    46.         delFile(`${folderPaths}${lists[i].filename}`, folderPaths) //调用删除方法
    47.     }
    48.     zip
    49.         .generateNodeStream({ type: 'nodebuffer', streamFiles: true })
    50.         .pipe(fs.createWriteStream(outPath))  //打包后的包名可以自己根据需求定义，路径可以根据需求更改
    51.         .on('finish', () => {
    52.             console.log(`${outPath} written.`);   //管道写完数据后，打印出提示
    53.         });
    54. }
    56. /**
    57.  * 读取文件list
    58.  * @author: 惜神
    59.  * @param {String} path 文件夹路径
    60.  * @Date: 2021-08-17 17:34:21
    61.  */
    62. const readFileList = (path, filesList) => {
    63.     const files = fs.readdirSync(path);
    64.     files.forEach((item) => {
    65.         const stat = fs.statSync(`${path}${item}`);
    66.         if (stat.isDirectory()) {
    67.             //递归读取文件
    68.             readFileList(`${path}${item}/`, filesList)
    69.         } else {
    70.             let obj = {};//定义一个对象存放文件的路径和名字
    71.             obj.path = path;//路径
    72.             obj.filename = item//名字
    73.             filesList.push(obj);
    74.         }
    75.     })
    76. }
    78. /**
    79.  * 获取文件
    80.  * @author: 惜神
    81.  * @Date: 2021-08-17 17:33:58
    82.  */
    83. const getFiles = {
    84.     //获取文件夹下的所有文件
    85.     getFileList: (path) => {
    86.         const filesList = [];
    87.         readFileList(path, filesList);
    88.         return filesList;
    89.     },
    90.     //获取文件夹下的所有图片
    91.     getImageFiles: (path) => {
    92.         const imageList = [];
    93.         this.getFileList(path).forEach((item) => {
    94.             const ms = image(fs.readFileSync(`${item.path}${item.filename}`));
    95.             ms.mimeType && (imageList.push(item.filename))
    96.         });
    97.         return imageList;
    98.     }
    99. };
    101. /**
    102.  * 检查是否是空文件夹
    103.  * @author: 惜神
    104.  * @param {String} file 文件路径
    105.  * @Date: 2021-08-18 14:07:16
    106.  */
    107. const fileExists = (file) => {
    108.     fs.access(`${file}`, fs.constants.F_OK, (err) => {
    109.         if(err) {
    110.             return false
    111.         }
    112.         fs.readdir(`${file}/`,function(err,fileArr){
    113.             if(err){
    114.                 return false
    115.             }
    116.             if(fileArr.length === 0) {
    117.                 return false
    118.             }
    119.             return true
    120.         })
    121.       });
    122. }
    124. /**
    125.  * 移动文件夹
    126.  * @author: 惜神
    127.  * @param {String} dstpath 加载文件夹路径
    128.  * @param {String} sourcePath 来源文件夹路径
    129.  * @Date: 2021-08-18 12:16:53
    130.  */
    131. const mvFiles = (dstpath, sourcePath) => {
    132.     const status = fileExists(sourcePath);
    133.     if(!status) return;
    134.     fs.rename(sourcePath, dstpath, (err) => {
    135.         if (err) {
    136.             console.log('move file',err)
    137.         }
    138.         mkdirSync(sourcePath)
    139.     })
    140. }
    142. /**
    143.  * 删除文件下的文件
    144.  * @author: 惜神
    145.  * @param {String} path 文件夹下所有图片的路径
    146.  * @param {String} reservePath 文件夹路径
    147.  * @Date: 2021-08-17 17:26:25
    148.  */
    149. const delFile = (path, reservePath) => {
    150.         if (fs.existsSync(path)) {
    151.             if (fs.statSync(path).isDirectory()) {
    152.                 let files = fs.readdirSync(path);
    153.                 files.forEach((file, index) => {
    154.                     let currentPath = `${path}/${file}`;
    155.                     if (fs.statSync(currentPath).isDirectory()) {
    156.                         delFile(currentPath, reservePath);
    157.                     } else {
    158.                         fs.unlinkSync(currentPath);
    159.                     }
    160.                 });
    161.                 if (path != reservePath) {
    162.                     fs.rmdirSync(path);
    163.                 }
    164.             } else {
    165.                 fs.unlinkSync(path);
    166.             }
    167.         }
    168.     }
    170.     /**
    171.      * 图片链接处理
    172.      * @author: 惜神 
    173.      * @param {String} dstpath 打包图片路径
    174.      * @param {String} imageList 图片数组
    175.      * @Date: 2021-08-18 12:17:36
    176.      */    
    177.     const linkTodo = async (dstpath, imageList) => {
    178.         if(imageList && imageList.length === 0) return;
    179.         mkdirSync(dstpath);
    180.         for (const item of imageList) {
    181.             const arg = new URL(item);
    182.             const fileName = arg.pathname.split('/').slice(-1)[0];
    183.             const downloadUrl = `${dstpath}/${fileName}`;
    184.             request(item).pipe(fs.createWriteStream(downloadUrl))
    185.         }
    186.     }
    187.     /**
    188.      * code 处理
    189.      * @author: 惜神
    190.      * @param {String} dstpath 打包图片路径
    191.      * @param {String} codeList code数组
    192.      * @Date: 2021-08-18 12:18:17
    193.      */
    194.     const codeTodo = async (dstpath, codeList) => {
    195.         if(codeList && codeList.length === 0) return;
    196.         mkdirSync(dstpath);
    197.         codeList.forEach(async (code, index) => {
    198.             const fileName = `code_${code}_${index}`;
    199.             const downloadUrl = `${dstpath}/${fileName}.png`;
    200.             try {
    201.                 await QRCode.toFile(downloadUrl, code, {
    202.                     color: {
    203.                         dark: '#FFFF',
    204.                         light: '#0000'
    205.                     }
    206.                 })
    207.             } catch (err) {
    208.                 console.error(err)
    209.             }
    210.         });
    211.     }
    212.     /**
    213.      * 文件目录处理
    214.      * @author: 惜神
    215.      * @param {*} dstpath 打包图片路径
    216.      * @param {*} sourcePath 来源图片路径
    217.      * @Date: 2021-08-18 12:19:42
    218.      */
    219.     const folderTodo = async (dstpath, sourcePath) => {
    220.        await mvFiles(dstpath, sourcePath);
    221.     }
    223.     /**
    224.      * @author: 惜神
    225.      * @param {String} dstpath 导出文件夹路径
    226.      * @param {Array} imageList 图片链接
    227.      * @param {Array} codeList code数组
    228.      * @param {String} sourcePath 图片来源路径
    229.      * @param {String} type 属输入类型
    230.      * @param {String} outPath 压缩图片压缩包输出路径
    231.      * @Date: 2021-08-17 16:58:47
    232.      */
    233.     (async ({ dstpath = "./img", imageList = [], outPath = "out.zip", type =
    234.         "link", codeList = [], sourcePath = "./testImage" }) => {
    235.         const map = {
    236.             'link': await linkTodo(dstpath, imageList),
    237.             'folder': await folderTodo(dstpath, sourcePath),
    238.             'code': await codeTodo(dstpath, codeList)
    239.         }
    240.         console.log(type)
    241.         map[type];
    242.         const folderPaths = `${dstpath}/`;
    243.         setTimeout(() => { packZipList(folderPaths, outPath) }, 1000);
    244.     })(
    245.         /********* 图片链接参数 **********/
    246.         {
    247.             dstpath: "./img",
    248.             imageList: [
    249.                 "https://cdn-scp.banu.cn/ideas/ideas/1617243660362-448561514.jpeg",
    250.                 "https://cdn-scp.banu.cn/ideas/ideas/1617243660548-7283341.jpeg"
    251.             ],
    252.             outPath: "out.zip",
    253.             type: "link"
    254.         }
    256.         /********** 二维码字符串参数 **********/
    257.         // {
    258.         //     dstpath: "./img",
    259.         //     codeList: ['1','2','桌位码:32'],
    260.         //     outPath: "out.zip",
    261.         //     type: "code"
    262.         // }
    264.         /********** 固定路径图片串参数 **********/
    265.         // {
    266.         //     dstpath: "./img",
    267.         //     sourcePath: "./testImage",
    268.         //     outPath: "out.zip",
    269.         //     type: "folder"
    270.         // }
    271.     )