使用Nodejs完成文件操作代码集合

Nodejs实现文件操作的代码集合

最近有一个小项目需要做一个桌面程序，所用使用了 Electron-vue + nodejs进行开发，借此机会学习了一下nodejs的一些操作，因为以前长时间做后端工作，对于nodejs也是只是了解，没有正儿八经的使用过，这里就总结一下自己写的一些文件操作代码，留个备份吧~

• 注意：下面方法中会出现相互引用的情况，所以如果那个方法中引用了其他方法，可查询一下，都在这里。

引用的包

const fs = require("fs-extra");
const path = require("path");
const join = require("path").join;
const request = require("request");
const compressing = require("compressing");		// 用于文件压缩
const pump = require("pump");			// 用于文件压缩

自定义日志

/**
 * 自定义log，一个简单的日志定义，在测试时会打开，发布时会关闭，下面代码中用到的打印日志用的这个的方法
 */
const customLogSwitch = true;
export function logger(msg) {
  if (customLogSwitch) {
    console.log(msg);
  }
}

判断是否为文件

/**
 * 判断是否为文件
 * @param filePath  文件路径
 * @return Boolean
 */
export function isFile(filePath) {
  let stats = fs.statSync(filePath);
  return stats.isFile();
}

判断是否为目录

/**
 * 判断是否为目录
 * @param dirPath  目录路径
 * @return Boolean
 */
export function isDirectory(dirPath) {
  let stats = fs.statSync(dirPath);
  return stats.isDirectory();
}

判断文件（目录）是否存在

/**
 * 判断文件（目录）是否存在
 * @param filePath  目录路径
 * @return Boolean
 */
export function isExistFile(filePath) {
    if (!filePath) {
        return false;
    }
  return fs.pathExistsSync(filePath);
}

判断文件（目录）是否不存在

/**
 * 判断文件（目录）是否不存在
 * @param filePath  目录路径
 * @return Boolean
 */
export function isNotExistFile(filePath) {
    if (!filePath) {
        return true;
    }
    return !fs.pathExistsSync(filePath);
}

判断给定的文件名称是否在目录中使用过

/**
 * 判断给定的文件名称是否在目录中使用过
 * @param dirPath   目录路径
 * @param fileName  文件名称
 */
export function isExistFileInDir(dirPath, fileName) {
    if (isNotExistFile(dirPath)) {
        return false;
    }
    let files = fs.readdirSync(dirPath);
    let isExist = false;
    files.forEach(function (item) {
        if (item == fileName) {
            isExist = true;
        }
    });
    return isExist;
}

创建目录（同步）

/**
 * 创建目录（同步）
 * @param dirPath 目录路径
 * @return Boolean
 */
export function createDir(dirPath) {
  if (isNotExistFile(dirPath)) {
    try {
        fs.ensureDirSync(dirPath);
        return true;
    } catch (e) {
      logger(e);
      return false;
    }
  }
  return false;
}

创建文件（同步）

/**
 * 创建文件（同步）
 * @param filePath  文件路径
 * @return Boolean
 */
export function createFile(filePath) {
  if (isNotExistFile(filePath)) {
      try {
          fs.ensureFileSync(filePath);
          return true;
      } catch (e) {
          logger(e);
          return false;
      }
  }
  return false;
}

修改文件名

/**
 * 修改文件名，若传递的两个文件路径不同，则会修改文件所在位置
 * @param oldFilePath	原文件路径
 * @param newFilePath	新文件路径
 * @return Promise
 *
 * renameFile("xxx", "xxx").then(() => {}).catch(error => {});
 *
 */
export function renameFile(oldFilePath, newFilePath) {
    return fs.rename(oldFilePath, newFilePath);
}

读取指定文件内容

/**
 * 读取指定文件内容
 * @param filePath  文件路径
 * @return Promise
 *
 * readFile("xxx").then(content => {内容处理}).catch(error => {});
 *
 */
export function readFile(filePath) {
  return fs.readFile(filePath, "UTF-8");
}

将指定内容信息写入指定文件中

/**
 * 将指定内容信息写入指定文件中
 * @param filePath  文件路径
 * @param content   写入内容
 * @return Promise
 *
 * writeFile("xxx", "content").then(() => {}).catch(error => {});
 *
 */
export function writeFile(filePath, content) {
  return fs.outputFile(filePath, content);
}

移动文件（目录）

/**
 * 移动文件（目录）,若目标目录不存在，会自动创建
 * @param sourcePath    源路径
 * @param targetPath    目标路径
 * @return Promise
 *
 * moveFile("xxxxx", "xxxx").then(() => {}).catch(error => {});
 *
 */
export function moveFile(sourcePath, targetPath) {
  return fs.move(sourcePath, targetPath);
}

删除文件（目录）（异步）

/**
 * 删除文件（目录）,若删除目录，则会递归删除目录下的所有文件（目录）
 * @param filePath  文件（目录）路径
 * @return Promise
 *
 * removeFile("xxxxx").then(() => {}).catch(error => {});
 *
 */
export function removeFile(filePath) {
    return fs.remove(filePath);
}

删除文件（目录）（同步）

/**
 * 同步删除文件（目录）
 * @param filePath 文件（目录）路径
 */
export function removeFileSync(filePath) {
    try {
        fs.removeSync(filePath);
        return true;
    } catch (e) {
        logger(e);
        return false;
    }
}

复制文件到指定目标目录（异步）

/**
 * 复制（拷贝）文件到指定目标目录
 * @param sourceFilePath
 * @param targetDirPath
 */
export function copyFile(sourceFilePath, targetDirPath) {
    return new Promise(function (resolve, reject) {
        if (isNotExistFile(sourceFilePath)) {
            reject("源文件不存在，请检查");
            return;
        }
        if (isDirectory(sourceFilePath)) {
            reject("源文件为目录，无法复制");
            return;
        }
        let targetFileName = path.basename(sourceFilePath);
        let targetFilePath = getFilePath(targetDirPath, targetFileName);
        let readable = fs.createReadStream(sourceFilePath);
        let writable = fs.createWriteStream(targetFilePath);
        writable.on('pipe', (src) => {
            logger("[复制文件（目录）] [有数据正在通过管道流入写入器] src: " + src);
        });
        writable.on('finish', () => {
            logger("[复制文件（目录）] [写入完成] 源文件：" + sourceFilePath + "，目标文件：" + targetFilePath);
            resolve("文件（目录）复制成功");
        });
        writable.on('error', error => {
            logger("[复制文件（目录）] [写入报错] 源文件：" + sourceFilePath + "，目标文件：" + targetFilePath + "  error：" + error);
            reject("文件（目录）复制失败");
        });
        // 通过管道写入数据到目标文件
        readable.pipe(writable);
    });
}

拷贝文件（同步）

/**
 * 同步拷贝文件
 * @param sourceFilePath    源文件路径
 * @param targetFilePath    目标文件路径
 * @return {boolean}
 */
export function copyFileSync(sourceFilePath, targetFilePath) {
    try {
        // 写文件
        fs.writeFileSync(targetFilePath, fs.readFileSync(sourceFilePath));
        return true;
    } catch (e) {
        console.error(e);
        return false;
    }
}

拷贝指定文件到指定目录

/**
 * 拷贝指定文件到指定目录
 * @param sourceFilePath    源文件路径
 * @param targetDirPath     目标目录路径
 */
export function copyFileSyncToDir(sourceFilePath, targetDirPath) {
    let targetFileName = path.basename(sourceFilePath);
    let targetFilePath = getFilePath(targetDirPath, targetFileName);
    // 引用上面的方法
    return copyFileSync(sourceFilePath, targetFilePath);
}

拷贝源文件列表到指定目录（同步）

/**
 * 同步拷贝源文件列表到指定目录
 * @param sourceFilePathList    源文件路径列表
 * @param targetDirPath         目标目录路径
 */
export function copyFileListSync(sourceFilePathList, targetDirPath) {
    if (!sourceFilePathList) {
        console.error("[拷贝文件列表] [源文件列表为空]");
        return false;
    }
    try {
        sourceFilePathList.forEach(function (sourceFilePath) {
            if (!copyFileSyncToDir(sourceFilePath, targetDirPath)) {
                console.error("[拷贝文件列表] [拷贝文件失败] 源文件：" + sourceFilePath + "，目标文件：" + targetFilePath);
            }
        });
        return true;
    } catch (e) {
        console.error(e);
        return false;
    }
}

拷贝目录（同步）

/**
 * 拷贝目录
 * @param sourceDirPath     源目录路径
 * @param targetDirPath     目标目录路径
 */
export function copyDirSync(sourceDirPath, targetDirPath) {
    /**
     * 拷贝目录文件
     * @param src   源目录
     * @param dist  目标目录
     */
    function copyDirFile(src, dist) {
        let paths = fs.readdirSync(src)
        paths.forEach(function(p) {
            let _src = join(src, p);
            let _dist = getFilePath(dist, p);
            let stat = fs.statSync(_src);
            // 判断是文件还是目录
            if(stat.isFile()) {
                fs.writeFileSync(_dist, fs.readFileSync(_src));
            }
            // 当是目录是，递归复制
            else if(stat.isDirectory()) {
                copyDir(_src, _dist)
            }
        })
    }
    /*
     * 复制目录、子目录，及其中的文件
     * @param src {String}      要复制的目录
     * @param dist {String}     复制到目标目录
     */
    function copyDir(src, dist){
        createDir(dist);
        copyDirFile(src, dist);
    }
    copyDir(sourceDirPath, targetDirPath);
}

获取文件名称（会检查名称是否存在）

该方法会检查文件名称在对应目录中是否使用过，若使用过，则会更改文件名，然后再递归检查，知道没有重复，然后返回生成的文件名。

/**
 * 获取目标文件名称
 * @param   dirPath     目录路径
 * @param   fileName    目标文件名
 * @param   index   序号
 */
export function getFilePath(dirPath, fileName, index=0) {
    let tmpFileName = "";
    if (index == 0) {
        tmpFileName = fileName;
    } else {
        let suffix = path.extname(fileName);
        let fileNamePrefix = getFileNamePrefix(fileName);
        tmpFileName = index == 1 ? fileNamePrefix + "_copy" + suffix : fileNamePrefix + "_copy" + "_" + index + suffix;
    }
    let targetFilePath = join(dirPath, tmpFileName);
    if (isExistFile(targetFilePath)) {
        index += 1;
        return getFilePath(dirPath, fileName, index);
    }
    return targetFilePath;
}

下载文件

/**
 * 下载文件
 * @param downloadUrl   下载路径
 * @param fileSavePath  文件保存路径
 */
export function download(downloadUrl, fileSavePath) {
  return new Promise(function (resolve, reject) {
      let option = {
          url : encodeURI(downloadUrl),
          method : "GET"
      }
      try {
          let saveDirPath = path.dirname(fileSavePath);
          if (isNotExistFile(saveDirPath)) {
              createDir(saveDirPath);
          }

          let writer = fs.createWriteStream(fileSavePath);
          nodeJsRequest(option).pipe(writer);
          // 文件写入失败
          writer.on("error", error => {
              console.error(error);
              removeFileSync(fileSavePath);
              reject({result : false, message : "文件下载失败"});
          });
          // 文件写入成功
          writer.on("finish", () => {
              resolve({result : true, message : "文件下载成功"});
          });
      } catch (e) {
          console.error(e);
          reject({result : false, message : "文件下载失败"});
      }
  });
}

下载指定ZIP文件并解压到指定目录

/**
 * 下载指定ZIP文件并解压到指定目录
 * @param rootPath    解压根目录
 * @param downloadUrl   ZIP文件下载URL
 * @param unzipDirName  ZIP包解压之后使用的目录名称
 */
export function downloadAndUnzip(rootPath, downloadUrl, unzipDirName) {
    // 下载文件
    let zipSavePath = join(rootPath, unzipDirName + ".zip");
    // 文件解压保存目录
    let unzipFileSavePath = join(rootPath, unzipDirName);
    // 下载ZIP文件
    return download(downloadUrl, zipSavePath)
            // 解压ZIP文件
            .then(() => { return unzip(zipSavePath, unzipFileSavePath) })
            // 删除下载的ZIP文件
            .then(() => {
                removeFileSync(zipSavePath);
                return Promise.resolve("ZIP文件下载并解压缩成功")
            })
            // 报错处理
            .catch(error => {
                console.error(error);
                removeFileSync(zipSavePath);
                return Promise.reject("ZIP文件下载并解压失败");
            });
}

对指定目录进行ZIP压缩

/**
 * 对指定目录进行ZIP压缩
 * @param zipDirPath    需要ZIP压缩的目录路径
 * @param zipSavePath   ZIP压缩文件保存路径
 */
export function zip(zipDirPath, zipSavePath) {
    logger("[ZIP压缩] 压缩目录路径：" + zipDirPath);
    logger("[ZIP压缩] 压缩文件保存路径：" + zipSavePath);
    return compressing.zip.compressDir(zipDirPath, zipSavePath);
}

对指定目录里的文件（目录）进行ZIP压缩

对指定目录里的文件（目录）进行ZIP压缩，压缩之后的文件不包括源根目录

/**
 * 对指定目录里的文件（目录）进行ZIP压缩，压缩之后的文件不包括源根目录
 * @param zipDirPath    需要ZIP压缩的目录路径
 * @param zipSavePath   ZIP压缩文件保存路径
 * @return {*}
 */
export function zipFile(zipDirPath, zipSavePath) {
    return new Promise(function (resolve, reject) {
        let zipStream = new compressing.zip.Stream();
        let fileList = fs.readdirSync(zipDirPath);
        fileList.forEach(function (item) {
            let fPath = join(zipDirPath, item);
            zipStream.addEntry(fPath);
        })
        const destStream = fs.createWriteStream(zipSavePath);
        pump(zipStream, destStream, err => {
            if (err) {
                console.error(err);
                reject("文件压缩失败");
            } else {
                resolve("文件压缩成功");
            }
        });
    });
}

对指定ZIP文件进行解压缩

/**
 * 对指定ZIP文件进行解压缩，并保存到指定目录
 * @param zipFilePath   ZIP压缩文件路径
 * @param unzipSavePath     解压缩之后保存路径
 */
export function unzip(zipFilePath, unzipSavePath) {
    logger("[UNZIP解压缩] 压缩文件路径：" + zipFilePath);
    logger("[UNZIP解压缩] 解压路径：" + unzipSavePath);
    return compressing.zip.uncompress(zipFilePath, unzipSavePath);
}

获取文件后缀类型

/**
 * 获取文件后缀类型
 * @param filePath 文件路径
 * */
export function getFileSuffix(filePath) {
    let value = "";
    if (filePath.lastIndexOf(".") >= 0) {
        value = filePath.substring(filePath.lastIndexOf(".") + 1);
    } else {
        value = filePath;
    }
    value = value.replace(/\s*/g,"");
    return value;
}

获取文件名前缀

/**
 * 获取文件名前缀
 * @param fileName  文件名
 */
export function getFileNamePrefix(fileName) {
    let value = "";
    if (fileName.lastIndexOf(".") >= 0) {
        value = fileName.substring(0, fileName.lastIndexOf("."));
    } else {
        value = fileName;
    }
    value = value.replace(/\s*/g,"");
    return value;
}```