Sistema de gestión de archivos basado en Node.js (con código fuente)

fsIntroducción al módulo

Node.js proporciona un conjunto de módulos que se pueden usar para interactuar con el sistema de archivos (de manera similar a las funciones POSIX estándar) fs. Cómo utilizar:

const fs = require('fs');

Todas las operaciones del sistema de archivos son sincrónicas, de devolución de llamada y basadas en promesas.

ejemplo

Sincronizar

El formulario síncrono bloquea el bucle de eventos de Node.js y la ejecución adicional de JavaScript hasta que se completa la operación. Las excepciones se lanzan inmediatamente y se pueden manejar con try... catch o bubbled.

const fs = require('fs');

try {
    
    
  fs.unlinkSync('文件');
  console.log('已成功删除文件');
} catch (err) {
    
    
  // 处理错误
}

llamar de vuelta

El formulario asíncrono siempre toma una devolución de llamada de finalización como su último argumento. Los parámetros pasados ​​a la devolución de llamada de finalización dependen del método específico, pero el primer parámetro siempre se reserva para las excepciones. Si la operación se completó con éxito, el primer parámetro será nulo o indefinido. (Inserte un anuncio: si necesita abrir el WebStorm genuino, puede contactarme, 56 yuanes al año, la licencia genuina está activada y el sitio web oficial puede verificar el período de validez. Si lo necesita, agrégueme en WeChat: poxiaozhiai6, Observaciones: 914.)

const fs = require('fs');

fs.unlink('文件', (err) => {
    
    
  if (err) throw err;
  console.log('已成功删除文件');
});

Promesa

Las operaciones basadas en promesas devuelven promesas (resueltas cuando se completa la operación asincrónica).

const fs = require('fs');

(async function(path) {
    
    
  try {
    
    
    await fs.unlink(path);
    console.log(`已成功删除 ${
      
      path}`);
  } catch (error) {
    
    
    console.error('出错：', error.message);
  }
})('文件');

sistema de gestión de documentos

Este ejemplo se basa nodejsen un sistema de administración de archivos visuales de interfaz de usuario que proporciona algunas operaciones comunes de archivos (carpetas), incluida la lectura, creación, copia, movimiento, eliminación y cambio de nombre de archivos (carpetas) .

operación de archivo

leer archivo

Se puede leer el tamaño del archivo, el nombre, el tipo, la hora de creación, la hora de modificación, etc.

const readfile = async (dir, filename) => {
    
    
  const fullname = fixpath(`${
      
      dir}/${
      
      filename}`);
  if (!fs.existsSync(fullname)) {
    
    
    throw Error(`[${
      
      fullname}] 文件或文件夹不存在!`);
  }
  const stats = await fs.statSync(fullname);
  if (stats.isFile()) {
    
    
    return {
    
    
      dir,
      filename,
      type: filename.split('.').slice(-1)[0],
      size: stats.size,
      mtime: stats.mtime,
      birthtime: stats.birthtime,
    };
  } else if (stats.isDirectory()) {
    
    
    return {
    
    
      dir,
      filename,
      type: 'dir',
      size: stats.size,
      mtime: stats.ctime,
      birthtime: stats.birthtime,
    };
  }
};

leer carpeta

const readdir = async dir => {
    
    
  dir = fixpath(dir);
  if (!fs.existsSync(dir)) {
    
    
    throw Error(`[${
      
      dir}] 文件夹不存在!`);
  }
  const files = await fs.readdirSync(dir);
  const result = [];
  for(let i = 0, l = files.length; i < l; i++) {
    
    
    try {
    
    
      const fileInfo = await readfile(dir, files[i]);
      result.push(fileInfo);
    } catch (err) {
    
    
      continue;
    }
  }
  return result;
};

crear un archivo

const touch = async (filename, override = true) => {
    
    
  filename = fixpath(filename);
  if (fs.existsSync(filename)) {
    
    
    if (!override) {
    
    
      throw Error(`[${
      
      filename}] 文件已存在!`);
    }
    await rmfile(filename);
  }
  await fs.writeFileSync(filename, '');
  return filename;
};

crear carpeta

const mkdir = async (dirname, override = true) => {
    
    
  dirname = fixpath(dirname);
  if (fs.existsSync(dirname)) {
    
    
    if (!override) {
    
    
      throw Error(`[${
      
      dirname}] 文件夹已存在!`);
    }
    await rmfile(dirname);
  }
  await fs.mkdirSync(dirname);
  return dirname;
};

Copiar archivos (carpetas)

const copyfile = async (src, dst) => {
    
    
  src = fixpath(src);
  dst = fixpath(dst);
  if (!fs.existsSync(src)) {
    
    
    throw Error(`[${
      
      src}] 文件或文件夹不存在!`);
  }
  const stats = await fs.statSync(src);
  if (stats.isFile()) {
    
    
    const filename = src.split('/').slice(-1)[0];
    let dstfile = `${
      
      dst}/${
      
      filename}`;
    if (fs.existsSync(dstfile)) {
    
    
      dstfile = `${
      
      dst}/${
      
      +new Date()}_${
      
      filename}`;
    }
    await fs.copyFileSync(src, dstfile);
    return dstfile;
  }
  if (stats.isDirectory()) {
    
    
    const filename = src.split('/').slice(-1)[0];
    let dstfile = `${
      
      dst}/${
      
      filename}`;
    if (fs.existsSync(dstfile)) {
    
    
      dstfile = `${
      
      dst}/${
      
      +new Date()}_${
      
      filename}`;
    }
    await fs.mkdirSync(dstfile);
    const files = await fs.readdirSync(src);
    for(let i = 0, l = files.length; i < l; i++) {
    
    
      await copyfile(`${
      
      src}/${
      
      files[i]}`, dstfile);
    }
    return dstfile;
  }
};

eliminar archivo (carpeta)

const rmfile = async path => {
    
    
  path = fixpath(path);
  if (!fs.existsSync(path)) {
    
    
    throw Error(`[${
      
      path}] 文件或文件夹不存在!`);
  }
  const stats = await fs.statSync(path);
  if (stats.isFile()) {
    
    
    await fs.unlinkSync(path);
    return path;
  }
  if (stats.isDirectory()) {
    
    
    const files = await fs.readdirSync(path);
    for(let i = 0, l = files.length; i < l; i++) {
    
    
      await rmfile(`${
      
      path}/${
      
      files[i]}`);
    }
    await fs.rmdirSync(path);
    return path;
  }
};

Mover archivos (carpetas)

const movefile = async (src, dst) => {
    
    
  await copyfile(src, dst);
  await rmfile(src);
};

Cambiar el nombre de un archivo (carpeta)

const rnfile = async (path, newpath) => {
    
    
  newpath = fixpath(newpath);
  path = fixpath(path);
  if (!fs.existsSync(path)) {
    
    
    throw Error(`[${
      
      path}] 文件或文件夹不存在!`);
  }
  fs.renameSync(path, newpath);
};

interfaz de servicio

interfaz de operación de archivos del servidor nodejs

const startServer = app => {
    
    
  app.get('/fs/readdir', async (req, res) => {
    
    
    const {
    
    path} = req.query;
    try {
    
    
      const result = await readdir(path);
      res.status(200).send({
    
    result});
    } catch (error) {
    
    
      res.status(500).send({
    
    message: error.message});
    }
  });
  app.get('/fs/touch', async (req, res) => {
    
    
    const {
    
    path, override} = req.query;
    try {
    
    
      await touch(path, override);
      res.status(200).send({
    
    message: '操作成功！'});
    } catch (error) {
    
    
      res.status(500).send({
    
    error});
    }
  });
  app.get('/fs/rmfile', async (req, res) => {
    
    
    const {
    
    path} = req.query;
    try {
    
    
      await rmfile(path);
      res.status(200).send({
    
    message: '操作成功！'});
    } catch (error) {
    
    
      res.status(500).send({
    
    error});
    }
  });
  ...
};

Configuración de la interfaz de front-end

const apiList = projectId => [
  {
    
    
    name: 'readfile',
    url: '/readfile',
  },
  {
    
    
    name: 'readdir',
    url: '/readdir',
  },
  {
    
    
    name: 'mkdir',
    url: '/mkdir',
  },
  {
    
    
    name: 'touch',
    url: '/touch',
  },
  {
    
    
    name: 'copyfile',
    url: '/copyfile',
  },
  {
    
    
    name: 'movefile',
    url: '/movefile',
  },
  {
    
    
    name: 'rmfile',
    url: '/rmfile',
  },
  {
    
    
    name: 'rnfile',
    url: '/rnfile',
  },
];

función

maximizar ventana

<MaxSize panel={fileRef} target={document.body} />

menú de clic derecho

<Drop trigger="contextMenu" dropList={fileDrop(filename)}>
  <div>{filename}</div>
</Drop>

Conversión automática de unidades de archivo

const fixFileSizeUnit = (size, base = 1024) => {
    
    
  const kb = size / base;
  if (kb < base) {
    
    
    return `${
      
      kb.toFixed(3) - 0} KB`;
  }
  const mb = kb / base;
  if (mb < base) {
    
    
    return `${
      
      mb.toFixed(3) - 0} M`;
  }
  const gb = mb / base;
  return `${
      
      gb.toFixed(3) - 0} G`;
};

Descarga del código fuente del sistema

Enlace de descarga: https://wwb.lanzouy.com/iS2bP0botapa