js实现的文件操作类封装，50个实例

最新推荐文章于 2023-10-08 18:57:39 发布
最新推荐文章于 2023-10-08 18:57:39 发布
阅读量337 收藏 4
点赞数
分类专栏： JavaScript ChatGPT 文章标签： javascript 前端 json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh6526157/article/details/129658452
版权

js实现的文件操作类封装，100个实例

  1. 创建文件夹
javascriptfunction createFolder(folderPath) {
  if (!fs.existsSync(folderPath)) {
    fs.mkdirSync(folderPath);
  }
}
  1. 删除文件夹
javascriptfunction deleteFolder(folderPath) {
  if (fs.existsSync(folderPath)) {
    fs.readdirSync(folderPath).forEach(function(file) {
      var curPath = folderPath + "/" + file;
      if (fs.lstatSync(curPath).isDirectory()) {
        deleteFolder(curPath);
      } else {
        fs.unlinkSync(curPath);
      }
    });
    fs.rmdirSync(folderPath);
  }
}
  1. 读取文件
javascriptfunction readFile(filePath) {
  return fs.readFileSync(filePath, "utf-8");
}
  1. 写入文件
javascriptfunction writeFile(filePath, data) {
  fs.writeFileSync(filePath, data);
}
  1. 追加文件
javascriptfunction appendFile(filePath, data) {
  fs.appendFileSync(filePath, data);
}
  1. 重命名文件
javascriptfunction renameFile(oldFilePath, newFilePath) {
  fs.renameSync(oldFilePath, newFilePath);
}
  1. 删除文件
javascriptfunction deleteFile(filePath) {
  fs.unlinkSync(filePath);
}
  1. 复制文件
javascriptfunction copyFile(sourceFilePath, targetFilePath) {
  fs.copyFileSync(sourceFilePath, targetFilePath);
}
  1. 判断文件是否存在
javascriptfunction fileExists(filePath) {
  return fs.existsSync(filePath);
}
  1. 获取文件信息
javascriptfunction getFileInfo(filePath) {
  return fs.statSync(filePath);
}
  1. 获取文件大小
javascriptfunction getFileSize(filePath) {
  return getFileInfo(filePath).size;
}
  1. 获取文件创建时间
javascriptfunction getFileCreateTime(filePath) {
  return getFileInfo(filePath).birthtime;
}
  1. 获取文件修改时间
javascriptfunction getFileModifyTime(filePath) {
  return getFileInfo(filePath).mtime;
}
  1. 获取文件访问时间
javascriptfunction getFileAccessTime(filePath) {
  return getFileInfo(filePath).atime;
}
  1. 获取文件扩展名
javascriptfunction getFileExtension(filePath) {
  return path.extname(filePath);
}
  1. 获取文件名
javascriptfunction getFileName(filePath) {
  return path.basename(filePath);
}
  1. 获取文件所在目录
javascriptfunction getFileDir(filePath) {
  return path.dirname(filePath);
}
  1. 获取目录下所有文件
javascriptfunction getFilesInFolder(folderPath) {
  return fs.readdirSync(folderPath);
}
  1. 获取目录下所有文件（包括子目录）
javascriptfunction getAllFilesInFolder(folderPath) {
  var files = [];
  fs.readdirSync(folderPath).forEach(function(file) {
    var curPath = folderPath + "/" + file;
    if (fs.lstatSync(curPath).isDirectory()) {
      files = files.concat(getAllFilesInFolder(curPath));
    } else {
      files.push(curPath);
    }
  });
  return files;
}
  1. 获取目录下所有子目录
javascriptfunction getSubFoldersInFolder(folderPath) {
  var folders = [];
  fs.readdirSync(folderPath).forEach(function(file) {
    var curPath = folderPath + "/" + file;
    if (fs.lstatSync(curPath).isDirectory()) {
      folders.push(curPath);
      folders = folders.concat(getSubFoldersInFolder(curPath));
    }
  });
  return folders;
}
  1. 获取文件内容行数
javascriptfunction getFileLineCount(filePath) {
  return readFile(filePath).split("\n").length;
}
  1. 获取文件内容单词数
javascriptfunction getFileWordCount(filePath) {
  return readFile(filePath).split(/\W+/).length;
}
  1. 获取文件内容字符数
javascriptfunction getFileCharCount(filePath) {
  return readFile(filePath).length;
}
  1. 判断文件是否为空
javascriptfunction isFileEmpty(filePath) {
  return getFileCharCount(filePath) === 0;
}
  1. 判断文件是否为图片
javascriptfunction isImageFile(filePath) {
  var ext = getFileExtension(filePath).toLowerCase();
  return ext === ".jpg" || ext === ".jpeg" || ext === ".png" || ext === ".gif";
}
  1. 判断文件是否为文本文件
javascriptfunction isTextFile(filePath) {
  var ext = getFileExtension(filePath).toLowerCase();
  return ext === ".txt" || ext === ".md" || ext === ".html" || ext === ".css" || ext === ".js";
}
  1. 判断文件是否为可执行文件
javascriptfunction isExecutableFile(filePath) {
  var ext = getFileExtension(filePath).toLowerCase();
  return ext === ".exe" || ext === ".sh" || ext === ".bat";
}
  1. 获取文件内容（逐行处理）
javascriptfunction getFileContent(filePath, lineHandler) {
  var content = readFile(filePath);
  content.split("\n").forEach(lineHandler);
}
  1. 获取文件内容（逐个字符处理）
javascriptfunction getFileContent(filePath, charHandler) {
  var content = readFile(filePath);
  for (var i = 0; i < content.length; i++) {
    charHandler(content.charAt(i));
  }
}
  1. 获取文件内容（逐个单词处理）
javascriptfunction getFileContent(filePath, wordHandler) {
  var content = readFile(filePath);
  content.split(/\W+/).forEach(wordHandler);
}
  1. 获取文件内容（按指定分隔符处理）
javascriptfunction getFileContent(filePath, separator, handler) {
  var content = readFile(filePath);
  content.split(separator).forEach(handler);
}
  1. 获取文件内容（转换为JSON对象）
javascriptfunction getFileContentAsJson(filePath) {
  return JSON.parse(readFile(filePath));
}
  1. 获取文件内容（转换为XML对象）
javascriptfunction getFileContentAsXml(filePath) {
  return new DOMParser().parseFromString(readFile(filePath), "text/xml");
}
  1. 获取文件内容（转换为HTML对象）
javascriptfunction getFileContentAsHtml(filePath) {
  return new DOMParser().parseFromString(readFile(filePath), "text/html");
}
  1. 获取文件内容（转换为Markdown对象）
javascriptfunction getFileContentAsMarkdown(filePath) {
  return marked(readFile(filePath));
}
  1. 获取文件内容（转换为PDF）
javascriptfunction getFileContentAsPdf(filePath, pdfPath) {
  var pdf = require("html-pdf");
  var html = getFileContentAsHtml(filePath);
  pdf.create(html).toFile(pdfPath, function(err, res) {
    if (err) return console.log(err);
    console.log(res);
  });
}
  1. 获取文件内容（转换为图片）
javascriptfunction getFileContentAsImage(filePath, imagePath) {
  var Canvas = require("canvas");
  var Image = Canvas.Image;
  var canvas = new Canvas(200, 200);
  var ctx = canvas.getContext("2d");
  var img = new Image();
  img.onload = function() {
    ctx.drawImage(img, 0, 0);
    fs.writeFileSync(imagePath, canvas.toBuffer());
  };
  img.src = readFile(filePath);
}
  1. 获取文件内容（转换为音频）
javascriptfunction getFileContentAsAudio(filePath, audioPath) {
  var ffmpeg = require("ffmpeg");
  try {
    var video = new ffmpeg(filePath);
    video.fnExtractSoundToMP3(audioPath, function(error, file) {
      if (!error) {
        console.log("Audio file: " + file);
      } else {
        console.log("Error: " + error);
      }
    });
  } catch (e) {
    console.log(e);
  }
}
  1. 获取文件内容（转换为视频）
javascriptfunction getFileContentAsVideo(filePath, videoPath) {
  var ffmpeg = require("ffmpeg");
  try {
    var video = new ffmpeg(filePath);
    video.fnExtractSoundToMP3(videoPath, function(error, file) {
      if (!error) {
        console.log("Video file: " + file);
      } else {
        console.log("Error: " + error);
      }
    });
  } catch (e) {
    console.log(e);
  }
}
  1. 获取文件内容（转换为压缩文件）
javascriptfunction getFileContentAsZip(filePath, zipPath) {
  var archiver = require("archiver");
  var output = fs.createWriteStream(zipPath);
  var archive = archiver("zip", {
    zlib: { level: 9 }
  });
  output.on("close", function() {
    console.log("Zip file: " + archive.pointer() + " total bytes");
  });
  archive.on("error", function(err) {
    throw err;
  });
  archive.pipe(output);
  archive.append(readFile(filePath), { name: getFileName(filePath) });
  archive.finalize();
}
  1. 获取文件内容（转换为Excel文件）
javascriptfunction getFileContentAsExcel(filePath, excelPath) {
  var XLSX = require("xlsx");
  var workbook = XLSX.readFile(filePath);
  XLSX.writeFile(workbook, excelPath);
}
  1. 获取文件内容（转换为Word文件）
javascriptfunction getFileContentAsWord(filePath, wordPath) {
  var mammoth = require("mammoth");
  mammoth.convertToHtml({ path: filePath }).then(function(result) {
    var html = result.value;
    var messages = result.messages;
    fs.writeFileSync(wordPath, html);
  });
}
  1. 获取文件内容（转换为PowerPoint文件）
javascriptfunction getFileContentAsPowerPoint(filePath, pptPath) {
  var PptxGenJS = require("pptxgenjs");
  var pptx = new PptxGenJS();
  pptx.addSlide();
  pptx.save(pptPath);
}
  1. 获取文件内容（转换为PDF表格）
javascriptfunction getFileContentAsPdfTable(filePath, pdfPath) {
  var pdfmake = require("pdfmake");
  var content = readFile(filePath);
  var docDefinition = {
    content: [
      {
        layout: "lightHorizontalLines", // optional
        table: {
          headerRows: 1,
          widths: ["*", "auto", 100, "*"],
          body: [
            ["First", "Second", "Third", "The last one"],
            ["Value 1", "Value 2", "Value 3", "Value 4"],
            ["Val 1", "Val 2", "Val 3", "Val 4"],
            ["Val 1", "Val 2", "Val 3", "Val 4"]
          ]
        }
      }
    ]
  };
  var pdfDoc = pdfmake.createPdf(docDefinition);
  pdfDoc.getBase64(function(data) {
    fs.writeFileSync(pdfPath, data, "base64");
  });
}
  1. 获取文件内容（转换为HTML表格）
javascriptfunction getFileContentAsHtmlTable(filePath, htmlPath) {
  var content = readFile(filePath);
  var table = "<table>\n";
  var rows = content.split("\n");
  for (var i = 0; i < rows.length; i++) {
    table += "  <tr>\n";
    var cells = rows[i].split(",");
    for (var j = 0; j < cells.length; j++) {
      table += "    <td>" + cells[j] + "</td>\n";
    }
    table += "  </tr>\n";
  }
  table += "</table>";
  fs.writeFileSync(htmlPath, table);
}
  1. 获取文件内容（转换为JSON表格）
javascriptfunction getFileContentAsJsonTable(filePath, jsonPath) {
  var content = readFile(filePath);
  var rows = content.split("\n");
  var keys = rows[0].split(",");
  var table = [];
  for (var i = 1; i < rows.length; i++) {
    var cells = rows[i].split(",");
    var row = {};
    for (var j = 0; j < cells.length; j++) {
      row[keys[j]] = cells[j];
    }
    table.push(row);
  }
  fs.writeFileSync(jsonPath, JSON.stringify(table));
}
  1. 获取文件内容（转换为Markdown表格）
javascriptfunction getFileContentAsMarkdownTable(filePath, markdownPath) {
  var content = readFile(filePath);
  var rows = content.split("\n");
  var keys = rows[0].split(",");
  var table = "| " + keys.join(" | ") + " |\n";
  table += "| " + keys.map(function() { return "---"; }).join(" | ") + " |\n";
  for (var i = 1; i < rows.length; i++) {
    var cells = rows[i].split(",");
    table += "| " + cells.join(" | ") + " |\n";
  }
  fs.writeFileSync(markdownPath, table);
}
  1. 获取文件内容（转换为PDF图表）
javascriptfunction getFileContentAsPdfChart(filePath, pdfPath) {
  var pdfmake = require("pdfmake");
  var content = readFile(filePath);
  var docDefinition = {
    content: [
      {
        chart: {
          type: "bar",
          data: {
            labels: ["Red", "Blue", "Yellow", "Green", "Purple", "Orange"],
            datasets: [
              {
                label: "# of Votes",
                data: [12, 19, 3, 5, 2, 3],
                backgroundColor: [
                  "rgba(255, 99, 132, 0.2)",
                  "rgba(54, 162, 235, 0.2)",
                  "rgba(255, 206, 86, 0.2)",
                  "rgba(75, 192, 192, 0.2)",
                  "rgba(153, 102, 255, 0.2)",
                  "rgba(255, 159, 64, 0.2)"
                ],
                borderColor: [
                  "rgba(255, 99, 132, 1)",
                  "rgba(54, 162, 235, 1)",
                  "rgba(255, 206, 86, 1)",
                  "rgba(75, 192, 192, 1)",
                  "rgba(153, 102, 255, 1)",
                  "rgba(255, 159, 64, 1)"
                ],
                borderWidth: 1
              }
            ]
          },
          options: {
            scales: {
              yAxes: [
                {
                  ticks: {
                    beginAtZero: true
                  }
                }
              ]
            }
          }
        }
      }
    ]
  };
  var pdfDoc = pdfmake.createPdf(docDefinition);
  pdfDoc.getBase64(function(data) {
    fs.writeFileSync(pdfPath, data, "base64");
  });
}
  1. 获取文件内容（转换为HTML图表）
javascriptfunction getFileContentAsHtmlChart(filePath, htmlPath) {
  var content = readFile(filePath);
  var chart = "<canvas id=\"myChart\"></canvas>";
  chart += "<script>";
  chart += "var ctx = document.getElementById(\"myChart\").getContext(\"2d\");";
  chart += "var myChart = new Chart(ctx, {";
  chart += "  type: \"bar\",";
  chart += "  data: {";
  chart += "    labels: [\"Red\", \"Blue\", \"Yellow\", \"Green\", \"Purple\", \"Orange\"],";
  chart += "    datasets: [{";
  chart += "      label: \"# of Votes\",";
  chart += "      data: [12, 19, 3, 5, 2, 3],";
  chart += "      backgroundColor: [";
  chart += "        \"rgba(255, 99, 132, 0.2)\",";
  chart += "        \"rgba(54, 162, 235, 0.2)\",";
  chart += "        \"rgba(255, 206, 86, 0.2)\",";
  chart += "        \"rgba(75, 192, 192, 0.2)\",";
  chart += "        \"rgba(153, 102, 255, 0.2)\",";
  chart += "        \"rgba(255, 159, 64, 0.2)\"";
  chart += "      ],";
  chart += "      borderColor: [";
  chart += "        \"rgba(255, 99, 132, 1)\",";
  chart += "        \"rgba(54, 162, 235, 1)\",";
  chart += "        \"rgba(255, 206, 86, 1)\",";
  chart += "        \"rgba(75, 192, 192, 1)\",";
  chart += "        \"rgba(153, 102, 255, 1)\",";
  chart += "        \"rgba(255, 159, 64, 1)\"";
  chart += "      ],";
  chart += "      borderWidth: 1";
  chart += "    }]";
  chart += "  },";
  chart += "  options: {";
  chart += "    scales: {";
  chart += "      yAxes: [{";
  chart += "        ticks: {";
  chart += "          beginAtZero: true";
  chart += "        }";
  chart += "      }]";
  chart += "    }";
  chart += "  }";
  chart += "});";
  chart += "</script>";
  fs.writeFileSync(htmlPath, chart);
}

  1. 创建文件夹：
class FileManager {
  static createFolder(path) {
    if (!fs.existsSync(path)) {
      fs.mkdirSync(path);
      console.log(`Folder ${path} created successfully`);
    } else {
      console.log(`Folder ${path} already exists`);
    }
  }
}
  1. 创建文件：
class FileManager {
  static createFile(path, content) {
    fs.writeFileSync(path, content);
    console.log(`File ${path} created successfully`);
  }
}
  1. 读取文件：
class FileManager {
  static readFile(path) {
    const content = fs.readFileSync(path, "utf8");
    console.log(`File ${path} read successfully`);
    return content;
  }
}
  1. 写入文件：
class FileManager {
  static writeFile(path, content) {
    fs.writeFileSync(path, content);
    console.log(`File ${path} written successfully`);
  }
}
  1. 追加文件：
class FileManager {
  static appendFile(path, content) {
    fs.appendFileSync(path, content);
    console.log(`File ${path} appended successfully`);
  }
}
  1. 删除文件：
class FileManager {
  static deleteFile(path) {
    if (fs.existsSync(path)) {
      fs.unlinkSync(path);
      console.log(`File ${path} deleted successfully`);
    } else {
      console.log(`File ${path} does not exist`);
    }
  }
}
  1. 复制文件：
class FileManager {
  static copyFile(sourcePath, destinationPath) {
    fs.copyFileSync(sourcePath, destinationPath);
    console.log(`File ${sourcePath} copied to ${destinationPath} successfully`);
  }
}
  1. 移动文件：
class FileManager {
  static moveFile(sourcePath, destinationPath) {
    fs.renameSync(sourcePath, destinationPath);
    console.log(`File ${sourcePath} moved to ${destinationPath} successfully`);
  }
}
  1. 重命名文件：
class FileManager {
  static renameFile(path, newName) {
    const newPath = path.replace(/[^\/]+$/, newName);
    fs.renameSync(path, newPath);
    console.log(`File ${path} renamed to ${newName} successfully`);
  }
}
  1. 获取文件信息：
class FileManager {
  static getFileInfo(path) {
    const stats = fs.statSync(path);
    console.log(`File ${path} info:`, stats);
    return stats;
  }
}
  1. 判断文件是否存在：
class FileManager {
  static fileExists(path) {
    return fs.existsSync(path);
  }
}
  1. 创建临时文件：
class FileManager {
  static createTempFile() {
    const tempFilePath = path.join(os.tmpdir(), `${Date.now()}.txt`);
    fs.writeFileSync(tempFilePath, "");
    console.log(`Temporary file ${tempFilePath} created successfully`);
    return tempFilePath;
  }
}
  1. 创建临时文件夹：
class FileManager {
  static createTempFolder() {
    const tempFolderPath = fs.mkdtempSync(path.join(os.tmpdir(), "temp-"));
    console.log(`Temporary folder ${tempFolderPath} created successfully`);
    return tempFolderPath;
  }
}
  1. 获取文件扩展名：
class FileManager {
  static getFileExtension(path) {
    const extension = path.split(".").pop();
    console.log(`File ${path} extension: ${extension}`);
    return extension;
  }
}
  1. 获取文件名：
class FileManager {
  static getFileName(path) {
    const fileName = path.split("/").pop();
    console.log(`File ${path} name: ${fileName}`);
    return fileName;
  }
}
  1. 获取文件夹名：
class FileManager {
  static getFolderName(path) {
    const folderName = path.split("/").slice(-2, -1)[0];
    console.log(`Folder ${path} name: ${folderName}`);
    return folderName;
  }
}
  1. 获取文件路径：
class FileManager {
  static getFilePath(path) {
    console.log(`File path: ${path}`);
    return path;
  }
}
  1. 获取文件夹路径：
class FileManager {
  static getFolderPath(path) {
    const folderPath = path.split("/").slice(0, -1).join("/");
    console.log(`Folder path: ${folderPath}`);
    return folderPath;
  }
}
  1. 获取文件大小：
class FileManager {
  static getFileSize(path) {
    const stats = fs.statSync(path);
    const fileSizeInBytes = stats.size;
    console.log(`File ${path} size: ${fileSizeInBytes} bytes`);
    return fileSizeInBytes;
  }
}
  1. 获取文件修改日期：
class FileManager {
  static getFileModificationDate(path) {
    const stats = fs.statSync(path);
    const modificationDate = stats.mtime;
    console.log(`File ${path} modification date: ${modificationDate}`);
    return modificationDate;
  }
}
  1. 获取文件访问日期：
class FileManager {
  static getFileAccessDate(path) {
    const stats = fs.statSync(path);
    const accessDate = stats.atime;
    console.log(`File ${path} access date: ${accessDate}`);
    return accessDate;
  }
}
  1. 获取文件创建日期：
class FileManager {
  static getFileCreationDate(path) {
    const stats = fs.statSync(path);
    const creationDate = stats.birthtime;
    console.log(`File ${path} creation date: ${creationDate}`);
    return creationDate;
  }
}
  1. 获取文件权限：
class FileManager {
  static getFilePermissions(path) {
    const stats = fs.statSync(path);
    const permissions = stats.mode.toString(8).slice(-3);
    console.log(`File ${path} permissions: ${permissions}`);
    return permissions;
  }
}
  1. 判断文件是否可读：
class FileManager {
  static isFileReadable(path) {
    try {
      fs.accessSync(path, fs.constants.R_OK);
      console.log(`File ${path} is readable`);
      return true;
    } catch (err) {
      console.log(`File ${path} is not readable`);
      return false;
    }
  }
}
  1. 判断文件是否可写：
class FileManager {
  static isFileWritable(path) {
    try {
      fs.accessSync(path, fs.constants.W_OK);
      console.log(`File ${path} is writable`);
      return true;
    } catch (err) {
      console.log(`File ${path} is not writable`);
      return false;
    }
  }
}
  1. 判断文件是否可执行：
class FileManager {
  static isFileExecutable(path) {
    try {
      fs.accessSync(path, fs.constants.X_OK);
      console.log(`File ${path} is executable`);
      return true;
    } catch (err) {
      console.log(`File ${path} is not executable`);
      return false;
    }
  }
}
  1. 判断文件是否是目录：
class FileManager {
  static isDirectory(path) {
    const stats = fs.statSync(path);
    const isDirectory = stats.isDirectory();
    console.log(`Path ${path} is a directory: ${isDirectory}`);
    return isDirectory;
  }
}
  1. 判断文件是否是文件：
class FileManager {
  static isFile(path) {
    const stats = fs.statSync(path);
    const isFile = stats.isFile();
    console.log(`Path ${path} is a file: ${isFile}`);
    return isFile;
  }
}
  1. 列出文件夹下的所有文件和文件夹：
class FileManager {
  static listFolderContents(path) {
    const contents = fs.readdirSync(path);
    console.log(`Contents of folder ${path}:`, contents);
    return contents;
  }
}
  1. 列出文件夹下的所有文件：
class FileManager {
  static listFiles(path) {
    const files = fs
      .readdirSync(path)
      .filter((file) => fs.statSync(path + "/" + file).isFile());
    console.log(`Files in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下的所有文件夹：
class FileManager {
  static listFolders(path) {
    const folders = fs
      .readdirSync(path)
      .filter((file) => fs.statSync(path + "/" + file).isDirectory());
    console.log(`Folders in folder ${path}:`, folders);
    return folders;
  }
}
  1. 列出文件夹下的所有文件和文件夹的详细信息：
class FileManager {
  static listFolderContentsDetails(path) {
    const contents = fs.readdirSync(path);
    const details = contents.map((item) => {
      const stats = fs.statSync(path + "/" + item);
      return {
        name: item,
        size: stats.size,
        isFile: stats.isFile(),
        isDirectory: stats.isDirectory(),
        modificationDate: stats.mtime,
        accessDate: stats.atime,
        creationDate: stats.birthtime,
        permissions: stats.mode.toString(8).slice(-3),
      };
    });
    console.log(`Details of contents in folder ${path}:`, details);
    return details;
  }
}
  1. 列出文件夹下指定扩展名的文件：
class FileManager {
  static listFilesByExtension(path, extension) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          file.split(".").pop() === extension
      );
    console.log(`Files with extension ${extension} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定前缀的文件：
class FileManager {
  static listFilesByPrefix(path, prefix) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          file.startsWith(prefix)
      );
    console.log(`Files with prefix ${prefix} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定后缀的文件：
class FileManager {
  static listFilesBySuffix(path, suffix) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          file.endsWith(suffix)
      );
    console.log(`Files with suffix ${suffix} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定大小的文件：
class FileManager {
  static listFilesBySize(path, size) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).size === size
      );
    console.log(`Files with size ${size} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之前修改的文件：
class FileManager {
  static listFilesModifiedBefore(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).mtime < date
      );
    console.log(`Files modified before ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之后修改的文件：
class FileManager {
  static listFilesModifiedAfter(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).mtime > date
      );
    console.log(`Files modified after ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之前访问的文件：
class FileManager {
  static listFilesAccessedBefore(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).atime < date
      );
    console.log(`Files accessed before ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之后访问的文件：
class FileManager {
  static listFilesAccessedAfter(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).atime > date
      );
    console.log(`Files accessed after ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之前创建的文件：
class FileManager {
  static listFilesCreatedBefore(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).birthtime < date
      );
    console.log(`Files created before ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 列出文件夹下指定日期之后创建的文件：
class FileManager {
  static listFilesCreatedAfter(path, date) {
    const files = fs
      .readdirSync(path)
      .filter(
        (file) =>
          fs.statSync(path + "/" + file).isFile() &&
          fs.statSync(path + "/" + file).birthtime > date
      );
    console.log(`Files created after ${date} in folder ${path}:`, files);
    return files;
  }
}
  1. 计算文件夹大小：
class FileManager {
  static getFolderSize(path) {
    let totalSize = 0;
    const contents = fs.readdirSync(path);
    contents.forEach((item) => {
      const itemPath = path + "/" + item;
      const stats = fs.statSync(itemPath);
      if (stats.isFile()) {
        totalSize += stats.size;
      } else if (stats.isDirectory()) {
        totalSize += this.getFolderSize(itemPath);
      }
    });
    console.log(`Folder ${path} size: ${totalSize} bytes`);
    return totalSize;
  }
}
  1. 计算文件夹中文件数量：
class FileManager {
  static countFiles(path) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) => fs.statSync(path + "/" + item).isFile()
    );
    console.log(`Number of files in folder ${path}: ${files.length}`);
    return files.length;
  }
}
  1. 计算文件夹中文件夹数量：
class FileManager {
  static countFolders(path) {
    const contents = fs.readdirSync(path);
    const folders = contents.filter(
      (item) => fs.statSync(path + "/" + item).isDirectory()
    );
    console.log(`Number of folders in folder ${path}: ${folders.length}`);
    return folders.length;
  }
}
  1. 计算文件夹中指定扩展名的文件数量：
class FileManager {
  static countFilesByExtension(path, extension) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) =>
        fs.statSync(path + "/" + item).isFile() &&
        item.split(".").pop() === extension
    );
    console.log(
      `Number of files with extension ${extension} in folder ${path}: ${files.length}`
    );
    return files.length;
  }
}
  1. 计算文件夹中指定前缀的文件数量：
class FileManager {
  static countFilesByPrefix(path, prefix) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) =>
        fs.statSync(path + "/" + item).isFile() && item.startsWith(prefix)
    );
    console.log(
      `Number of files with prefix ${prefix} in folder ${path}: ${files.length}`
    );
    return files.length;
  }
}
  1. 计算文件夹中指定后缀的文件数量：
class FileManager {
  static countFilesBySuffix(path, suffix) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) =>
        fs.statSync(path + "/" + item).isFile() && item.endsWith(suffix)
    );
    console.log(
      `Number of files with suffix ${suffix} in folder ${path}: ${files.length}`
    );
    return files.length;
  }
}
  1. 计算文件夹中指定大小的文件数量：
class FileManager {
  static countFilesBySize(path, size) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) =>
        fs.statSync(path + "/" + item).isFile() &&
        fs.statSync(path + "/" + item).size === size
    );
    console.log(
      `Number of files with size ${size} in folder ${path}: ${files.length}`
    );
    return files.length;
  }
}
  1. 计算文件夹中指定日期之前修改的文件数量：
class FileManager {
  static countFilesModifiedBefore(path, date) {
    const contents = fs.readdirSync(path);
    const files = contents.filter(
      (item) =>
        fs.statSync(path + "/" + item).isFile() &&
        fs.statSync(path + "/" + item).mtime < date
    );
    console.log(
      `Number of files modified before ${date} in folder ${path}: ${files.length}`
    );
    return files.length;
  1. 判断文件夹是否存在

Copy

class FileUtil {
  static folderExists(path) {
    return fs.existsSync(path);
  }
}

console.log(FileUtil.folderExists('./myFolder'));
  1. 获取文件夹名

Copy

class FileUtil {
  static getFolderName(path) {
    return path.split('/').pop();
  }
}

console.log(FileUtil.getFolderName('./myFolder'));
  1. 获取当前工作目录

Copy

class FileUtil {
  static getCurrentDirectory() {
    return process.cwd();
  }
}

console.log(FileUtil.getCurrentDirectory());
  1. 改变当前工作目录

Copy

class FileUtil {
  static changeCurrentDirectory(path) {
    process.chdir(path);
  }
}

FileUtil.changeCurrentDirectory('./myFolder');
console.log(FileUtil.getCurrentDirectory());
  1. 获取文件/文件夹的绝对路径

Copy

class FileUtil {
  static getAbsolutePath(path) {
    return path.resolve(path);
  }
}

console.log(FileUtil.getAbsolutePath('./myFile.txt'));
  1. 判断路径是否为绝对路径

Copy

class FileUtil {
  static isAbsolutePath(path) {
    return path.isAbsolute(path);
  }
}

console.log(FileUtil.isAbsolutePath('./myFile.txt'));
console.log(FileUtil.isAbsolutePath('/home/user/myFile.txt'));
  1. 获取路径的目录名

Copy

class FileUtil {
  static getDirectoryName(path) {
    return path.dirname(path);
  }
}

console.log(FileUtil.getDirectoryName('/home/user/myFile.txt'));
  1. 获取路径的文件名（带扩展名）

Copy

class FileUtil {
  static getBaseName(path) {
    return path.basename(path);
  }
}

console.log(FileUtil.getBaseName('/home/user/myFile.txt'));
  1. 获取路径的文件名（不带扩展名）

Copy

class FileUtil {
  static getBaseNameWithoutExtension(path) {
    return path.basename(path, path.extname(path));
  }
}

console.log(FileUtil.getBaseNameWithoutExtension('/home/user/myFile.txt'));
  1. 获取路径的扩展名

Copy

class FileUtil {
  static getExtensionName(path) {
    return path.extname(path);
  }
}

console.log(FileUtil.getExtensionName('/home/user/myFile.txt'));
  1. 获取路径的父级目录

Copy

class FileUtil {
  static getParentDirectory(path) {
    return path.dirname(path);
  }
}

console.log(FileUtil.getParentDirectory('/home/user/myFolder/myFile.txt'));
  1. 获取路径的相对路径

Copy

class FileUtil {
  static getRelativePath(sourcePath, destinationPath) {
    return path.relative(sourcePath, destinationPath);
  }
}

console.log(FileUtil.getRelativePath('/home/user/myFolder', '/home/user/myFolder/myFile.txt'));
  1. 检查路径是否为目录

Copy

class FileUtil {
  static isDirectory(path) {
    return fs.statSync(path).isDirectory();
  }
}

console.log(FileUtil.isDirectory('/home/user/myFolder'));
console.log(FileUtil.isDirectory('/home/user/myFile.txt'));
  1. 检查路径是否为文件

Copy

class FileUtil {
  static isFile(path) {
    return fs.statSync(path).isFile();
  }
}

console.log(FileUtil.isFile('/home/user/myFile.txt'));
console.log(FileUtil.isFile('/home/user/myFolder'));
  1. 获取路径的绝对路径

Copy

class FileUtil {
  static getAbsolutePath(path) {
    return path.resolve(path);
  }
}

console.log(FileUtil.getAbsolutePath('./myFile.txt'));
console.log(FileUtil.getAbsolutePath('/home/user/myFile.txt'));
  1. 获取路径的相对路径

Copy

class FileUtil {
  static getRelativePath(sourcePath, destinationPath) {
    return path.relative(sourcePath, destinationPath);
  }
}

console.log(FileUtil.getRelativePath('/home/user/myFolder', '/home/user/myFolder/myFile.txt'));
console.log(FileUtil.getRelativePath('/home/user/myFolder', '/home/user/otherFolder/myFile.txt'));
  1. 获取路径的绝对路径

Copy

class FileUtil {
  static getAbsolutePath(path) {
    return path.resolve(path);
  }
}

console.log(FileUtil.getAbsolutePath('./myFile.txt'));
console.log(FileUtil.getAbsolutePath('/home/user/myFile.txt'));
  1. 获取路径的相对路径

Copy

class FileUtil {
  static getRelativePath(sourcePath, destinationPath) {
    return path.relative(sourcePath, destinationPath);
  }
}

console.log(FileUtil.getRelativePath('/home/user/myFolder', '/home/user/myFolder/myFile.txt'));
console.log(FileUtil.getRelativePath('/home/user/myFolder', '/home/user/otherFolder/myFile.txt'));
  1. 获取路径的扩展名

Copy

class FileUtil {
  static getExtensionName(path) {
    return path.extname(path);
  }
}

console.log(FileUtil.getExtensionName('/home/user/myFile.txt'));
console.log(FileUtil.getExtensionName('/home/user/myFile'));
  1. 获取路径的文件名（带扩展名）

Copy

class FileUtil {
  static getBaseName(path) {
    return path.basename(path);
  }
}

console.log(FileUtil.getBaseName('/home/user/myFile.txt'));
console.log(FileUtil.getBaseName('/home/user/myFolder/'));

《代码爱好者》
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
js对本地文件操作
12-12
js对本地文件操作,仅限IE浏览器使用，其它浏览器不兼容（ActiveXObject方法）
js实现类的封装、继承、多态
weixin_39514724的博客
10-11 339
类 每个类都包含三个部分： 一：构造函数：供实例化对象用的 二：构造函数外的通过点语法添加的：这是供类使用的，实例化对象是访问不到的 三：类的原型中的：实例化对象可以通过其原型链进行间接的访问 封装 1、声明一个类： 首先声明一个函数保存在一个变量里，然后在这个函数（类）内部通过this（函数内部自带的一个变量，用于指向当前这个对象）变量添加属性或方法来实现对类添加属性或者方法。 new关键字可以...
js如何实现类
qq_45060976的博客
03-03 575
js如何实现类 方法一：使用原型 const Car = function (name,length){ this.name = name this.length = length } Car.prototype.run = function(){ console.log(`我是${this.name},我能跑${this.length}公里`) } car1 = new Car("奔驰","1000") car1.run() 方法二：用class class Car{ c
JS-4种实现面向对象类的方法
Web_boom的博客
06-01 2657
我们在编写和维护复杂或庞大的代码时，必须使用模块化策略。目前，业界的主流做法就是采用"面向对象编程"。我们把模块中的属性及方法封装起来，日后使用将非常方便，也可以避免繁琐重复的工作。 然而，Javascript与其他语言（如 java）不同，它不支持"类"（class），导致传统的面向对象编程方法无法直接使用。本文总结了Javascript中实现面向对象类的4种方式以及它们的使用方法，供大家学习参考。在 ES6中， (类) 作为对象的模板被引入，可以通过 关键字定义类。它可以被看作一个语法糖，让对象原型的
js开发：js实现类
Lpd_Reason的博客
10-24 2114
本文是博主学习过程中的总结，欢迎指点。 js并不是一门面向对象的语言，仅仅是一门基于WEB的脚本语言。但是可以根据js已有的特性来实现类的概念，方法如下： 1.构造函数的方法 function person（name,sex）{ this.name=name;//公有成员 this.sex=sex; var _this=this...
Javascript中类的实现
RaeZhang的博客
03-02 746
前言 最近在读《你不知道的Javascript》 系列，读到关于原型和类的部分，里面提到一个观点：js中只有对象，没有类这个概念。 在网上搜索关于“Javascript” 中是否有类 的问题，有很多争议。 一段比较准确的描述是： 在ECMAScript 6出现class的概念之后，才算是告别了直接通过原型对象来模拟类和类继承，但class也只是基于JavaScript原型继承的语法糖，并没有引入新的对象继承模式。 这篇文章并不是为 Js是否有"类" 这个问题盖棺定论，而是看Js具体是如何通过原型实现传统
js之文件相关操作
最新发布
AKelly的博客
10-08 553
File 对象是特殊类型的 Blob，且可以用在任意的 Blob 类型的 context 中。array：是一个由ArrayBuffer, ArrayBufferView, Blob, DOMString 等对象构成的 Array ，或者其他类似对象的混合体。Blob URL/Object URL 是一种伪协议，允许将 Blob 和 File 对象用作图像、二进制数据下载链接等的 URL 源。type：默认值为 “”，表示将会被放入到 blob 中的数组内容的 MIME 类型。
js 关于文件的操作
crazy_yun的博客
11-22 2294
1.读取某个文件的内容 var fs = require('fs'); // 读取文件 let buf = fs.readFileSync("test.json"); let data = fs.readFileSync("test.json", "utf8"); console.log("readFileSync(): buf",buf); // Buffer 数据 console.log("readFileSync(): data",data); // 按照 utf8 格式编码解析 // 异步
js中类的简单实现和理解
a1498665771的博客
02-11 162
js类的简单实现
javascript 里的类实现
weixin_34014555的博客
05-18 132
摘抄自《javascript高级程序设计》一书。javascript 是面向对象的语言，自然也有面向对象的一些特性。一：构造函数方式第一步选择类名，即构造函数的名字。下面的例子在构造函数里不创造对象，而是使用this，使用new 运算符调用构造函数的时候在执行第一行代码前先创建一个对象，这个对象只能用this访问，然后可以直接赋予this属性，默认情况下是构造函数的返回值，不必return。例子...
如何在JavaScript中对文件进行处理
忧郁的蛋的专栏
02-16 1846
生成压缩文件：使用 JSZip 对象的 generateAsync() 方法生成压缩文件，可以指定压缩格式，例如：zip.generateAsync({type:"blob"}).then(function (content) {…添加文件：使用 JSZip 对象的 file() 方法添加需要压缩的文件，例如：zip.file("file1.txt", "content1")。总之，不同的文件类型有不同的处理方法，JavaScript 提供了丰富的文件处理能力，可以读取、解析、显示各种类型的文件。
javascript封装的sqlite操作类实例
10-23
主要介绍了javascript封装的sqlite操作类,可实现SQLite数据库的初始化及执行SQL语句的功能,具有一定参考借鉴价值,需要的朋友可以参考下
C#实现的JS操作类实例
09-03
主要介绍了C#实现的JS操作类,封装了C#关于javascript的弹出对话框、返回上一页、跳转等常用操作,非常具有实用价值,需要的朋友可以参考下
C#Url操作类封装、仿Node.Js中的Url模块实例
09-01
主要介绍了C#Url操作类封装、仿Node.Js中的Url模块，实例分析了C#Url操作类封装的技巧，非常具有实用价值，需要的朋友可以参考下。
js实现类，详解函数模式
“明明很开心”的博客空间
05-16 259
ECMAScript中是没有类的概念的，它对于对象的定义是“无序属性的集合，其属性可以包含基本值、对象或者函数” 以下是几种js的函数模式来封装实现类以及他们的优缺点 工厂模式 工厂模式使用普通函数以根据参数创建一个包含需要的属性和方法的Person对象 function createPerson(name, age, job) { var o = new Object(); o.n...
JavaScript实现类的private、protected、public、static以及继承
热门推荐
Yorhom's Game Box
08-20 2万+
JavaScript实际上是一种弱类型语言，与C++和Java等语言不同。因此，在JavaScript中，没有强调类（class）这一概念，但实际运用中，类还是很重要的，比如写一款游戏，如果我们不停地调用函数来完成创建角色，移动角色的话，那会是什么样的呢？可能会出现非常多的重复代码，因此我们需要一个类来统一这些代码。所谓的类，就是把程序中的代码分类，比如说游戏中的关于角色的代码算作一类，游戏背景算作一类，游戏特效又是
Javascript中的类实现
amwayy的专栏
08-17 593
Javascript本身并不支持面向对象，它没有访问控制符，它没有定义类的关键字class，它没有支持继承的extend或冒号，它也没有用来支持虚函数的virtual，不过，Javascript是一门灵活的语言，下面我们就看看没有关键字class的Javascript如何实现类定义，并创建对象。 一：定义类并创建类的实例对象 在Javascript中，我们用function来定义类，如下：...
js面向对象三大特性之系列一 封装
yiyueqinghui的博客
07-03 1580
面向对象三大特性：封装，继承，多态 1、什么是封装 定义：把客观事物封装成抽象的类，隐藏属性和方法的实现细节，仅对外公开接口。 其实封装就是将属性和方法组成一个类的过程就称之为封装； 封装实现的三种方式： 分别是构造函数、原型、在类的外部通过.的语法添加 2、封装的三种方式 2.1、构造函数方法 构造函数添加属性和方法实际上也就是通过this添加的属性和方法 function Cat(name,age){ // 相当于 this = new Object() this.name = .
省市选择_js封装
comzheng的专栏
07-25 3058
DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">html xmlns="http://www.w3.org/1999/xhtml" >head>    title>无标题页title>    link href
使用async和await封装一个类
03-30
下面是一个使用async和await封装的类的示例： ```javascript class AsyncClass { async functionOne() { return new Promise((resolve, reject) => { // ... some async code if (/* async code succeeds */) {...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

《代码爱好者》

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值