CODEWITHSUNDEEP
node.js
Bdfy
Bdfy

Reputation: 24661

How to get totalsize of files in directory?

How to get totalsize of files in directory ? Best way ?

Upvotes: 15

Views: 21128

Answers (10)

Mitrajit Chandra
Mitrajit Chandra

Reputation: 11

A very simple synchronous solution that I implemented.

const fs = require("fs");
function getSize(path){
// Get the size of a file or folder recursively
let size = 0;
if(fs.statSync(path).isDirectory()){
    const files = fs.readdirSync(path);
    files.forEach(file => {
        size += getSize(path + "/" + file);
    });
}
else{
    size += fs.statSync(path).size;
}
return size;
}

Upvotes: 0

Andrew Odri
Andrew Odri

Reputation: 9432

This combines async/await and the fs Promises API introduced in Node.js v14.0.0 for a clean, readable implementation:

const { readdir, stat } = require('fs/promises');

const dirSize = async directory => {
  const files = await readdir( directory );
  const stats = files.map( file => stat( path.join( directory, file ) ) );

  let size = 0;
  for await ( const stat of stats ) size += stat.size;
  return size;
};

Usage:

const size = await dirSize( '/path/to/directory' );
console.log( size );

An shorter-but-less-readable alternative of the dirSize function would be:

const dirSize = async directory => {
  const files = await readdir( directory );
  const stats = files.map( file => stat( path.join( directory, file ) ) );

  return ( await Promise.all( stats ) ).reduce( ( accumulator, { size } ) => accumulator + size, 0 );
}

Upvotes: 1

Rahman Qadirzade
Rahman Qadirzade

Reputation: 145

function readSizeRecursive(folder, nested = 0) {
  return new Promise(function(resolve, reject) {
    const stats = fs.lstatSync(path.resolve(__dirname, '../projects/', folder));
    var total = stats.size;
    const list = fs.readdirSync(path.resolve(__dirname, '../projects/', folder));
    if(list.length > 0){
      Promise.all(list.map(async li => {
        const stat = await fs.lstatSync(path.resolve(__dirname, '../projects/', folder, li));
        if(stat.isDirectory() && nested == 0){
          const tt = await readSizeRecursive(folder, 1);
          total += tt;
        } else {
          total += stat.size;
        }
      })).then(() => resolve(convertBytes(total)));
    } else {
      resolve(convertBytes(total));
    }
  });
}

const convertBytes = function(bytes) {
  const sizes = ["Bytes", "KB", "MB", "GB", "TB"]

  if (bytes == 0) {
    return "n/a"
  }

  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)))

  if (i == 0) {
    return bytes + " " + sizes[i]
  }

  // return (bytes / Math.pow(1024, i)).toFixed(1) + " " + sizes[i]
  return parseFloat((bytes / Math.pow(1024, i)).toFixed(1));
}

Upvotes: 0

Joss Bird
Joss Bird

Reputation: 311

I know I'm a bit late to the part but I though I'd include my solution which uses promises based on @maerics answer:

const fs = require('fs');
const Promise = require('bluebird');

var totalSizeBytes=0;

fs.readdir('storage', function(err, files) {
    if (err) throw err;

    Promise.mapSeries(files, function(file){
        return new Promise((resolve, reject) => {
            fs.stat('storage/' + file,function(err, stats) {
                if (err) { throw err; }
                if (stats.isFile()) { totalSizeBytes += stats.size; resolve(); }
            });
        })
    }).then(()=>{
        console.log(totalSizeBytes);
    });

});

Upvotes: 0

Michael
Michael

Reputation: 6899

'use strict';

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

const getSize = (item, callback) => {
  let totalSize = 0;

  fs.lstat(item, (err, stats) => {
    if (err) return callback(err);

    if (stats.isDirectory()) {

      fs.readdir(item, (err, list) => {
        if (err) return callback(err);

        async.each(list, (listItem, cb) => {

          getSize(path.join(item, listItem), (err, size) => {
            totalSize += size;
            cb();
          });

        },
        (err) => {
          if (err) return callback(err);

          callback(null, totalSize);
        });

      });

    } else {
     // Ensure fully asynchronous API
      process.nextTick(function() {
        callback(null, (totalSize += stats.size))
      });
    }

  });

}

getSize('/Applications', (err, totalSize) => { if (!err) console.log(totalSize); });

Upvotes: 1

MT.
MT.

Reputation: 1925

I tested the following code and it works perfectly fine. Please do let me know if there is anything that you don't understand.

var util  = require('util'),
spawn = require('child_process').spawn,
size    = spawn('du', ['-sh', '/path/to/dir']);

size.stdout.on('data', function (data) {
  console.log('size: ' + data);
});


// --- Everything below is optional ---

size.stderr.on('data', function (data) {
  console.log('stderr: ' + data);
});

size.on('exit', function (code) {
  console.log('child process exited with code ' + code);
});

Courtesy Link

2nd method:

var util = require('util'), exec = require('child_process').exec, child;
child = exec('du -sh /path/to/dir', function(error, stdout, stderr){
    console.log('stderr: ' + stderr);
    if (error !== null){
        console.log('exec error: ' + error);
    }
});

You might want to refer the Node.js API for child_process

Upvotes: 5

catamphetamine
catamphetamine

Reputation: 4741

ES6 variant:

import path_module from 'path'
import fs from 'fs'

// computes a size of a filesystem folder (or a file)
export function fs_size(path, callback)
{
    fs.lstat(path, function(error, stats)
    {
        if (error)
        {
            return callback(error)
        }

        if (!stats.isDirectory())
        {
            return callback(undefined, stats.size)
        }

        let total = stats.size

        fs.readdir(path, function(error, names)
        {
            if (error)
            {
                return callback(error)
            }

            let left = names.length

            if (left === 0)
            {
                return callback(undefined, total)
            }

            function done(size)
            {
                total += size

                left--
                if (left === 0)
                {
                    callback(undefined, total)
                }
            }

            for (let name of names)
            {
                fs_size(path_module.join(path, name), function(error, size)
                {
                    if (error)
                    {
                        return callback(error)
                    }

                    done(size)
                })
            }
        }) 
    })
}

Upvotes: 3

loganfsmyth
loganfsmyth

Reputation: 161477

Here is a simple solution using the core Nodejs fs libraries combined with the async library. It is fully asynchronous and should work just like the 'du' command.

var fs = require('fs'),
    path = require('path'),
    async = require('async');

function readSizeRecursive(item, cb) {
  fs.lstat(item, function(err, stats) {
    if (!err && stats.isDirectory()) {
      var total = stats.size;

      fs.readdir(item, function(err, list) {
        if (err) return cb(err);

        async.forEach(
          list,
          function(diritem, callback) {
            readSizeRecursive(path.join(item, diritem), function(err, size) {
              total += size;
              callback(err);
            }); 
          },  
          function(err) {
            cb(err, total);
          }   
        );  
      }); 
    }   
    else {
      cb(err);
    }   
  }); 
}

Upvotes: 19

maerics
maerics

Reputation: 156444

Review the node.js File System functions. It looks like you can use a combination of fs.readdir(path, [cb]), and fs.stat(file, [cb]) to list the files in a directory and sum their sizes.

Something like this (totally untested):

var fs = require('fs');
fs.readdir('/path/to/dir', function(err, files) {
  var i, totalSizeBytes=0;
  if (err) throw err;
  for (i=0; i<files.length; i++) {
    fs.stat(files[i], function(err, stats) {
      if (err) { throw err; }
      if (stats.isFile()) { totalSizeBytes += stats.size; }
    });
  }
});
// Figure out how to wait for all callbacks to complete
//   e.g. by using a countdown latch, and yield total size
//   via a callback.

Note that this solution only considers the plain files stored directly in the target directory and performs no recursion. A recursive solution would come naturally by checking stats.isDirectory() and entering, although it likely complicates the "wait for completion" step.

Upvotes: 2

sasklacz
sasklacz

Reputation: 3628

Use du : https://www.npmjs.org/package/du

require('du')('/home/rvagg/.npm/', function (err, size) {
  console.log('The size of /home/rvagg/.npm/ is:', size, 'bytes')
})

Upvotes: 3

Related Questions