Obtenir la taille du dossier à l'aide de la commande du

du est une commande Linux. Il n'est généralement pas disponible sous Windows (aucune idée de Mac, désolé)

Le module child_process offre la possibilité de générer des processus enfants. Il semble que vous exécutez simplement la commande dans le système d'exploitation. Donc, pour faire fonctionner une solution sur plusieurs systèmes, vous pourriez avoir deux options:

• Vérification du système d'exploitation et exécution (avec spawn) de la commande système appropriée, comme vous le faites maintenant. Cela garde le code le plus simple
• Vous pouvez également utiliser le code JavaScript (il existe un certain nombre de questions dans StackOverflow sur la façon d'obtenir la taille du répertoire dans node.js). Je pense que ce serait le moyen le plus sûr de couvrir n'importe quel système d'exploitation sans se soucier de la prise en charge des commandes.

Vous devez avoir installé certains outils Linux dans votre système Windows, mais vous ne pouvez pas compter sur leur disponibilité dans n'importe quel Windows courant

1. Les fenêtres installées sur votre ordinateur peuvent avoir le sysinternals du . Il n'est pas présent dans toutes les installations Windows. Vous préférerez peut-être utiliser windirstat.info ou quelque chose de plus natif comme www.getfoldersize.com .

2. Étant donné qu'une commande UNIX et Linux pour estimer l'utilisation de l'espace fichier, elle devrait fonctionner dans n'importe quel système d'exploitation UNIX comme le système d'exploitation.

3. La commande du est un utilitaire de ligne de commande permettant de signaler l'utilisation de l'espace disque du système de fichiers. Il peut être utilisé pour découvrir l'utilisation du disque pour les fichiers et les dossiers et pour montrer ce qui occupe de l'espace. Il prend en charge l'affichage uniquement des répertoires ou de tous les fichiers, un total général, une sortie dans un format lisible par l'homme et peut être combiné avec d'autres outils UNIX pour générer une liste triée des plus gros fichiers de dossiers sur un système. Voir: https://shapeshed.com/unix-du/

Si vous en avez besoin pour fonctionner sous UNIX et non UNIX, vous devez d'abord vérifier quel système d'exploitation est utilisé par l'utilisateur de votre programme, puis exécuter une commande différente en fonction du système d'exploitation sur lequel il s'exécute.

/ p>

Code très primitif et sync. Pour le produit, vous devez passer aux fonctions asynchrones.

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

function dirsizeSync(dirname) {
    console.log(dirname);
    let size = 0;
    try {
        fs.readdirSync(dirname)
            .map(e => path.join(dirname, e))
            .map(e => {
                try {
                    return {
                        dirname: e,
                        stat: fs.statSync(e)
                    };
                } catch (ex) {
                    return null;
                }
            })
            .forEach(e => {
                if (e) {
                    if (e.stat.isDirectory()) {
                        size += dirsizeSync(e.dirname);
                    } else if (e.stat.isFile()) {
                        size += e.stat.size;
                    }
                }
            });
    } catch (ex) {}
    return size;
}

console.log(dirsizeSync('/tmp') + ' bytes');

Vous pouvez utiliser la commande intégrée node.js fs stat du package ... mais oh, ça va exploser en mémoire si vous faites un trajet entier. Il est préférable de s'en tenir probablement à des outils en dehors du nœud qui ont fait leurs preuves.

https://repl.it/@ CodyGeisler / GetDirectorySizeV2

const { promisify } = require('util');
const watch = fs.watch;
const readdir = promisify(fs.readdir);
const stat = promisify(fs.stat);
const path = require('path');
const { resolve } = require('path');


const getDirectorySize = async function(dir) {
  try{
    const subdirs = (await readdir(dir));
    const files = await Promise.all(subdirs.map(async (subdir) => {
      const res = resolve(dir, subdir);
      const s = (await stat(res));
      return s.isDirectory() ? getDirectorySize(res) : (s.size);
    }));
    return files.reduce((a, f) => a+f, 0);
  }catch(e){
    console.debug('Failed to get file or directory.');
    console.debug(JSON.stringify(e.stack, null, 2));
    return 0;
  }
};

(async function main(){
  try{
    // Be careful if directory is large or size exceeds JavaScript `Number` type
    let size = await getDirectorySize("./testfolder/")
    console.log('size (bytes)',size);
  }catch(e){
    console.log('err',e);
  }
})();

Je sais que cette question est un peu ancienne, mais récemment je me suis retrouvé à la recherche d'une réponse claire et courte sur la façon de le faire, si elle est utile à quelqu'un, eh bien, et si elle n'a pas seulement consommé quelques octets.

Je dois préciser que je ne suis pas un expert en quoi que ce soit, mais j'aime apprendre et c'est ce que j'ai appris en cherchant une solution à cela:

//If executed in a terminal
du 'path to file or directory including white spaces in names'
// returns something like
125485 path to file or directory including white spaces in names

Ce script est une opération synchrone

//Declares the required module
const execSync = require('child_process').execSync;
//Declare the directory or file path
const target = "Absolute path to dir or file";
/*
Declare a variable or constant to store the data returned,
parse data to Number and multiplying by 1024 to get total 
bytes
*/
const size = parseInt(execSync(`du '${target}'`)) * 1024;
//Finally return or send to console, the variable or constant used for store data
return size;

Avec exec ou execSync peut exécuter des fichiers, ou des commandes, dans le système Unix lorsque s'exécute du 'certain chemin' dans un terminal, obtient l'utilisation du disque du fichier ou du répertoire, et le pat absolu à nouveau, il est donc nécessaire de faire une analyse à l'entier du résultat, l'execSync obtient un tampon comme résultat.

J'utilise une chaîne de modèle comme paramètre pour éviter écrire plus de lignes de code puisque vous n'avez pas à gérer les problèmes d'espaces dans le chemin de la chaîne, cette méthode prend en charge ces espaces.

*/
First declare the needs of a Child Process and [execSync()][1]
"the method will not return until the child process has fully closed"
*/

Tout sur la commande du pour Unix

Je ne parle pas anglais nativement donc j'utilise un traducteur comme interprète, mes excuses pour les erreurs de langue.

Tout sur l'équivalent pour Windows