Une brève discussion sur fs.mkdir et fs.rmdir dans le module de fichiers Nodejs

Cet article vous présentera les opérations sur les fichiers Nodejs fs.mkdir et fs.rmdir. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

[Apprentissage recommandé : "Tutoriel Nodejs"]

Le répertoire de fichiers fs.mkdir est nouvellement ajouté

Utilisation de cas

• Les répertoires ajoutés niveau par niveau imprimeront avec succès le succès

fs.mkdir("a", function (err) {
    // 当a不存在的时候直接创建 a/b会报错
 if (err) {
    console.log(err);
    return;
  }
  console.log("success...");//success
});

• Cross-niveau si il n'existe pas Une erreur s'est produite lors de l'ajout d'un répertoire sous le répertoire ! ! , le module intégré du nœud lui-même ne prend pas en charge l'ajout de répertoires sous des répertoires inexistants (c'est ce que je veux faire)

fs . Version améliorée de mkdir

Version récursive

Idée

• Selon "/" Couper et générer un tableau. cache

• index initial value = 1 ; effectue slice(0, index) sur le tableau correspondant au chemin en séquence, intercepte et join('/') dans la chaîne de chemin currentPath

• fs.stat est utilisé pour décrire l'état du fichier. Si le fichier n'existe pas, une erreur se produit

• Une erreur s'est produite. la veille et appelé fs.mkdir (currentPath, appelez-vous de manière récursive);

• Le fichier existe et appelez-vous

Implémentation du code

function mkdir(pathStr, cb) {
  let pathList = pathStr.split("/");
  // 递归调用fs.mkdir
  let index = 1;
  function make(err) {
    if (err) return cb(err);
    if (index === pathList.length + 1) return cb();
    //每次 调用要将上次的已经生成的文件名做下次的目标文件，
    // 所以 slice(0, index) 第二参数也要 累加
    //slice(0, index) 截取后join('/')  成字符串
    let currentPath = pathList.slice(0, index++).join("/");
    // console.log("pathList.slice(0,index)", pathList.slice(0, index));
    fs.stat(currentPath, function (err) {
      if (err) {
        fs.mkdir(currentPath, make);
        console.log({ currentPath });
        // 如果不存在，再创建  fs.mkdir(currentPath, make);
      } else {
        make();
      }
    });
  }
  make();
}

Test :

Aucune erreur n'est signalée pour le moment

mkdir("a/b/c/d", function (err) {
  if (err) console.log(err);
   console.log("success...");
});

Effet d'impression

for loop + wait version

Idée d'implémentation

• Utilisez '/' comme base pour couper le chemin dans le tableau correspondant, et parcourir le tableau avec une boucle for

• ExistsSync() dans la boucle for utilise une méthode synchrone pour détecter si le répertoire existe.

Si le répertoire existe, retournez true , si le répertoire n'existe pas, retournez false 3. Il n'y a pas de fs.mkdir(currentPath)

Code d'implémentation

const fs = require("fs").promises; //node11后可以直接.promises
const { existsSync } = require("fs");
async function mkdir(pathStr, cb) {
  let pathList = pathStr.split("/");
  for (let i = 1; i <= pathList.length; i++) {
    let currentPath = pathList.slice(0, i).join("/");
    if (!existsSync(currentPath)) {
      await fs.mkdir(currentPath);
    }
  }
}

L'appel appellera récursivement la tuile puis l'appel en chaîne

mkdir("a/b/c/d")
  .then(() => {
    console.log("创建成功");
  })
  .catch((err) => {
    console.log(err);
  });

Effet d'impression

Suppression du répertoire de fichiers fs.rmdir

Utilisation du cas

Directement supprimer fs.rmdir dans les répertoires avec des sous-répertoires

const fs = require("fs");
const path = require("path");
fs.rmdir("a", function (err) {
  console.log(err);//会报错
});

Résultats d'utilisation (rapport d'erreur)

version améliorée de fs.rmdir

Version série

Idea

• fs.stat renverra les informations spécifiques du fichier : l'état du fichier Information, modification heure, heure de création, statut du répertoire ; le deuxième paramètre dans le rappel de fs.stat est d'obtenir l'objet fichier, la méthode objet : isFile, isDirectory

• isFile directement fs.unlink ( dir, cb); supprimer le fichier actuel

• isDirectory appelle fs.readdir pour renvoyer un tableau de sous-répertoires

• mapper le tableau de sous-répertoires Traverse & nom de fichier parent + nom de fichier enfant épissage path.join(dir, item))

• Appelez-vous récursivement sur le tableau de chemin épissé dans l'ordre

• Supprimer tous les sous-répertoires puis se supprimer

Implémentation du code

function rmdir(dir, cb) {
  fs.stat(dir, function (err, statObj) {
    // 1:判断dir的文件信息 statObj 是目录还是 文件
    if (statObj.isDirectory()) {
      // 1.1 读取文件夹fs.readdir 回调函数 里可以拿到文件夹读取结果
      fs.readdir(dir, function (err, dirs) {
        //   遍历 文件夹中文件，path 拼接 父文件名称+ 子文件名称
        dirs = dirs.map((item) => path.join(dir, item));
        // 把目录里面 的拿出来，一个删除后 删除下一个
        let index = 0;
        function step() {
          // 将子文件都删除完后，删除自己
          if (index === dirs.length) return fs.rmdir(dir, cb);
          //删除第一个成功后 继续调用rmdir 删除下一个子文件，直到index===dirs.length 时 删除自己
          rmdir(dirs[index++], step);
        }
        step();
      });
    } else {
      // 1.2 dir是文件 直接删除 用fs.unlink
      fs.unlink(dir, cb);
    }
  });
}

Test

rmdir("a", function () {
  console.log("删除成功");
});

Résultats d'exécution

Version parallèle

Implémentation du code

const fs = require("fs").promises;
const path = require("path");
async function rmdir(dir) {
  let statObj = await fs.stat(dir);
  if (statObj.isDirectory) {
    let dirs = await fs.readdir(dir);
    await Promise.all(dirs.map((item) => rmdir(path.join(dir, item))));
    await fs.rmdir(dir);
  } else {
    return fs.unlink(dir);
  }
}

Appel

rmdir("a").then(() => {
  console.log("并行删除成功");
});

Résultat de l'exécution

La différence entre parallèle et série

Série est comprise comme un seul thread qui ne peut exécuter le suivant qu'une fois l'exécution précédente terminée. Exécution parallèle et asynchrone, aucune dépendance les uns sur les autres Alors ce dernier sera plus efficace que le premier

L'essence du fonctionnement du répertoire de fichiers

• L'essence du répertoire de fichiers : c'est données arborescentes

• Le fonctionnement du répertoire de fichiers est le fonctionnement des données dans la structure arborescente

• Laisser un trou pour l'écriture suivante tempsArborescence Compréhension

Pour plus de connaissances liées à la programmation, veuillez visiter : Enseignement de la programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!