node服务器的文件系统（一些文件操作）

node服务器的文件系统

1. 获取文件下的所有文件

function getAll(dir) {
  var filesNameArr = [];

  // 用个hash队列保存每个目录的深度
  var mapDeep = {};
  mapDeep[dir] = 0;
  // 先遍历一遍给其建立深度索引
  function getMap(dir, curIndex) {
    var files = fs.readdirSync(dir); //同步拿到文件目录下的所有文件名

    files.map(function (file) {
      //var subPath = path.resolve(dir, file) //拼接为绝对路径
      var subPath = path.join(dir, file); //拼接为相对路径
      var stats = fs.statSync(subPath); //拿到文件信息对象
      // 必须过滤掉node_modules文件夹
      if (file != "node_modules") {
        mapDeep[file] = curIndex + 1;
        if (stats.isDirectory()) {
          //判断是否为文件夹类型
          return getMap(subPath, mapDeep[file]); //递归读取文件夹
        }
      }
    });
  }
  getMap(dir, mapDeep[dir]);
  function readdirs(dir, folderName) {
    var result = {
      //构造文件夹数据
      path: dir,
      fileName: path.basename(dir),
      fileType: "directory",
      deep: mapDeep[folderName],
      uploadFileTime: "",
      type: "folder",
      url: "",
      isLike: false,
    };
    var files = fs.readdirSync(dir); //同步拿到文件目录下的所有文件名

    result.children = files.map(function (file) {
      //var subPath = path.resolve(dir, file) //拼接为绝对路径
      var subPath = path.join(dir, file); //拼接为相对路径
      var stats = fs.statSync(subPath); //拿到文件信息对象
      let size = stats.size;

      let time = formatDate(stats.birthtime);
      let suffix = file.split(".")[file.split(".").length - 1];

      var type = "";

      if (stats.isDirectory()) {
        //判断是否为文件夹类型
        return readdirs(subPath, file, file); //递归读取文件夹
      }
      var imgUrl;
      if (picTypeList.indexOf(suffix) > -1) {
        type = "picture";
        let buf = fs.readFileSync(subPath); //读取图片
        let base64 = new Buffer.from(buf).toString("base64"); //将图片数据转化为base64编码数据
        imgUrl = `data:${suffix};base64,${base64}`;
      } else if (videoTypeList.indexOf(suffix) > -1) {
        type = "video";
        let buf = fs.readFileSync(subPath); //读取图片
        let base64 = new Buffer.from(buf).toString("base64"); //将图片数据转化为base64编码数据
        imgUrl = `data:${suffix};base64,${base64}`;
      }
      return {
        //构造文件数据
        path: subPath,
        fileName: file,
        fileType: suffix,
        fileSize: size,
        uploadFileTime: time,
        type: type,
        url: imgUrl || "",
        isLike: false,
      };
    return result; //返回数据
  }
  filesNameArr.push(readdirs(dir, dir));
  return filesNameArr;
}

2. 剪切复制文件夹

   方法一、
   function copyDirectory(src, dest) {
     var files = fs.readdirSync(src);//读取文件（src为剪切的文件路径）
     files.forEach((item, index) => {
       var itemPath = path.join(src, item);//path
       var itemStat = fs.statSync(itemPath); // 获取文件信息
       var savedPath = path.join(dest, itemPath.replace(src, ""));
       var savedDir = savedPath.substring(0, savedPath.lastIndexOf("\\"));
       if (itemStat.isFile()) {
         // 如果目录不存在则进行创建
         if (!fs.existsSync(savedDir)) {
           fs.mkdirSync(savedDir, { recursive: true });
         }
         // 写入到新目录下
         var data = fs.readFileSync(itemPath);
         fs.writeFileSync(savedPath, data);
         // 并且删除原文件
         fs.unlinkSync(itemPath);
       } else if (itemStat.isDirectory()) {
         copyDirectory(itemPath, path.join(savedDir, item));
       }
     });
     // 并且删除原目录
     fs.rmdirSync(src);
   }
   方法二、
    fs.rename(copyPath, newPath, function (err) {
             if (err) throw err;
             fs.stat(newPath, function (err, stats) {
               if (err) throw err;
               // console.log("stats: " + JSON.stringify(stats));
             });
           });
   

3. 搜索文件

function getAllDirbyFilename(dir, str) {
  if (str === "") {
    let searchfiles = getAll(dir);
    let list = [...searchfiles[0].children];
    return list;
  } else {
    let searchfiles = getAll(dir);
    let list = [...searchfiles[0].children];
    // let files = fs.readdirSync(dir); // 该文件夹下的所有文件名称 (文件夹 + 文件)
    let resultArr = [];

    list.forEach((item) => {
      if (item.type === "folder") {
        getAllDirbyFilename(dir + "/" + item.fileName, str);
      }
      if (item.fileName.indexOf(str) > -1) {
        resultArr.push(item);
      }
    });

    return resultArr;
  }
}

4. 删除文件夹

   const deleteFolder = (path) => {
     let files = [];
     if (fs.existsSync(path)) {
       files = fs.readdirSync(path);
       files.forEach((file) => {
         let curPath = path + "/" + file;
         if (fs.statSync(curPath).isDirectory()) {
           deleteFolder(curPath);
         } else {
           fs.unlinkSync(curPath);
         }
       });
       fs.rmdirSync(path);
     }
   };
   

   对表格内容进行操作

   let list = xlsx.parse("./deleteListInfo.xlsx");
   let department = list[0].data;
    //相对应的操作
   let xlsxObj = [
         {
           name: "删除信息",
           data: department,
         },
       ];
   let buffer = xlsx.build(xlsxObj);
   fs.writeFile(`./deleteListInfo.xlsx`, buffer, function (err) {
    if (err) throw err;
   });
   

5. 复制文件夹

var copy = function (src, dst) {
  // 读取目录中的所有文件/目录
  fs.readdir(src, function (err, paths) {
    if (err) {
      throw err;
    }

    paths.forEach(function (path) {
      var _src = src + "/" + path,
        _dst = dst + "/" + path,
        readable,
        writable;

      fs.stat(_src, function (err, st) {
        if (err) {
          throw err;
        }

        // 判断是否为文件
        if (st.isFile()) {
          // 创建读取流
          readable = fs.createReadStream(_src);
          // 创建写入流
          writable = fs.createWriteStream(_dst);
          // 通过管道来传输流
          readable.pipe(writable);
        }
        // 如果是目录则递归调用自身
        else if (st.isDirectory()) {
          exists(_src, _dst, copy);
        }
      });
    });
  });
};