node.js - node_modules - rimraf n est pas reconnu en tant que commande interne



Supprimer le répertoire qui n'est pas vide (9)

Dans mon application Node, je dois supprimer un répertoire fs.rmdir fichiers, mais fs.rmdir ne fonctionne que sur des répertoires vides. Comment puis-je faire ceci?


Answer #1

Il y a un module pour ce rimraf appelé ( https://npmjs.org/package/rimraf ). Il offre les mêmes fonctionnalités que rm -Rf

Utilisation de base:

var rimraf = require('rimraf');
rimraf('/some/directory', function () { console.log('done'); });

Answer #2

J'ai écrit cette fonction appelée supprimer le dossier. Il supprimera récursivement tous les fichiers et dossiers d'un emplacement. Le seul paquet requis est async.

var async = require('async');

function removeFolder(location, next) {
    fs.readdir(location, function (err, files) {
        async.each(files, function (file, cb) {
            file = location + '/' + file
            fs.stat(file, function (err, stat) {
                if (err) {
                    return cb(err);
                }
                if (stat.isDirectory()) {
                    removeFolder(file, cb);
                } else {
                    fs.unlink(file, function (err) {
                        if (err) {
                            return cb(err);
                        }
                        return cb();
                    })
                }
            })
        }, function (err) {
            if (err) return next(err)
            fs.rmdir(location, function (err) {
                return next(err)
            })
        })
    })
}

Answer #3

Je souhaite qu'il y ait un moyen de le faire sans modules supplémentaires pour quelque chose de si minuscule et commun, mais c'est le meilleur que je pourrais trouver.

Mise à jour: devrait maintenant fonctionner sur Windows (testé Windows 10), et devrait également fonctionner sur les systèmes Linux / Unix / BSD / Mac.

const
    execSync = require("child_process").execSync,
    fs = require("fs"),
    os = require("os");

let removeDirCmd, theDir;

removeDirCmd = os.platform() === 'win32' ? "rmdir /s /q " : "rm -rf ";

theDir = __dirname + "/../web-ui/css/";

// WARNING: Do not specify a sinle file as the windows rmdir command will error.
if (fs.existsSync(theDir)) {
    console.log(' removing the ' + theDir + ' directory.');
    execSync(removeDirCmd + '"' + theDir + '"', function (err) {
        console.log(err);
    });
}

Answer #4

La plupart des personnes utilisant fs avec Node.js aimeraient des fonctions proches de la "façon Unix" de traiter les fichiers. J'utilise fs-extra pour apporter tout ce qu'il y a de plus cool:

fs-extra contient des méthodes qui ne sont pas incluses dans le package vanilla Node.js fs. Tels que mkdir -p, cp -r, et rm -rf.

Encore mieux, fs-extra est une alternative au remplacement des fs natifs. Toutes les méthodes dans fs ne sont pas modifiées et y sont attachées. Cela signifie que vous pouvez remplacer fs par fs-extra :

// this can be replaced
var fs = require('fs')

// by this
var fs = require('fs-extra')

Answer #5

Si vous utilisez le nœud 8+, vous voulez une asynchronicité et ne voulez pas de dépendances externes, voici la version async / await:

const path = require('path');
const fs = require('fs');
const util = require('util');

const exists = util.promisify(fs.exists);
const readdir = util.promisify(fs.readdir);
const lstat = util.promisify(fs.lstat);
const unlink = util.promisify(fs.unlink);
const rmdir = util.promisify(fs.rmdir);

const removeDir = async (dir) => {
    if (await exists(dir)) {
        const files = await readdir(dir);
        await Promise.all(files.map(async (file) => {
            const p = path.join(dir, file);
            const stat = await lstat(p);
            if (stat.isDirectory()) {
                await removeDir(p);
            } else {
                await unlink(p);
                console.log(`Removed file ${p}`);
            }
        }))
        await rmdir(dir);
        console.log(`Removed dir ${dir}`);
    }
}

Answer #6

Un moyen rapide et sale (peut-être pour tester) pourrait être d'utiliser directement la méthode exec ou spawn pour invoquer l'appel OS pour supprimer le répertoire. En savoir plus sur NodeJs child_process .

let exec = require('child_process').exec
exec('rm -Rf /tmp/*.zip', callback)

Les inconvénients sont:

  1. Vous dépendez du système d'exploitation sous-jacent, c'est-à-dire que la même méthode s'exécuterait dans unix / linux mais probablement pas dans Windows.
  2. Vous ne pouvez pas détourner le processus sur des conditions ou des erreurs. Vous confiez simplement la tâche au système d'exploitation sous-jacent et attendez que le code de sortie soit renvoyé.

Avantages:

  1. Ces processus peuvent s'exécuter de manière asynchrone.
  2. Vous pouvez écouter la sortie / l'erreur de la commande, donc la sortie de la commande n'est pas perdue. Si l'opération n'est pas terminée, vous pouvez vérifier le code d'erreur et réessayer.

Answer #7

Utilisez simplement le module rmdir ! c'est simple et facile.


Answer #8

Version promisifiée:

const fs = require('fs')
const path = require('path')
const Q = require('q')

function rmdir(dir) {
  return Q.nfcall(fs.access, dir).then(() => {
    return Q.nfcall(fs.readdir, dir)
      .then(files => files.reduce((pre, f) => pre.then(() => {
        var sub = path.join(dir, f)
        return Q.nfcall(fs.lstat, sub).then(stat => {
          if (stat.isDirectory()) return rmdir(sub)
          return Q.nfcall(fs.unlink, sub)
        })
      }), Q()))
  }, err => {})
  .then(() => Q.nfcall(fs.rmdir, dir))
}

Answer #9

Pour supprimer le dossier de manière synchrone

var fs = require('fs');
var deleteFolderRecursive = function(path) {
  if (fs.existsSync(path)) {
    fs.readdirSync(path).forEach(function(file, index){
      var curPath = path + "/" + file;
      if (fs.lstatSync(curPath).isDirectory()) { // recurse
        deleteFolderRecursive(curPath);
      } else { // delete file
        fs.unlinkSync(curPath);
      }
    });
    fs.rmdirSync(path);
  }
};




filesystems