同步计算方法

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

// 同步计算，利用回调函数和递归来完成多层级目录中的文件大小计算
function calcSizeSync(dirPath,cb){
    let fileSize=0
    let error=null
    function calc(dirPath,cb1){
        const statObj=fs.statSync(dirPath)
        if(statObj.isDirectory()){
            try {
                const files=fs.readdirSync(dirPath)
                let dirs=files.map(item=>{
                    return path.join(dirPath,item)
                })
                let index = 0
                function next () {
                  if (index < dirs.length) return cb1&&cb1()
                  let current = dirs[index++]
                  calc(current, next)
                }
                next()
            } catch (err) {
                error=err
            }
            
        }else{
            fileSize+=statObj.size
            cb1&&cb1()
        }
    }
    calc(dirPath)
    cb(error,fileSize)
}

// 测试
calcSizeSync('test',(err,size)=>{
    if(err) console.log(err)
    else console.log("同步执行文件大小："+size)
})

异步计算方法，使用async/await

const fs=require('fs')
const path=require('path');
// 使用promisify方法来promise化指定方法
const { promisify } = require('util');
stat=promisify(fs.stat)
readdir=promisify(fs.readdir)

// 异步
async function calcSize(dirPath,cb){
    let fileSize=0;
    let error=null
    async function calc(dirPath){
        try {
            const statObj=await stat(dirPath)
            if(statObj.isDirectory()){
                const files=await readdir(dirPath)
                let dirs=files.map(item=>{
                    return path.join(dirPath,item)
                })
                let index = 0
                async function next () {
                    if (index < dirs.length){
                        let current = dirs[index++]
                        await calc(current)
                        await next()
                    }
                }
                return await next()
            }else{
                fileSize+=statObj.size
            }
        } catch (err) {
            error=err
        }
    }
    await calc(dirPath)
    cb(error,fileSize)
}

// 测试
calcSize('test',(err,size)=>{
    if(err) console.log(err)
    else console.log("异步执行文件大小："+size)
})

其他方法

/**
 * 获取指定目录内所有文件大小总和  单位为字节
 * @param dir
 * @param callback
 */
function getdirsize(dir,callback){
    var size = 0;
    fs.stat(dir,function(err,stats){
        if(err) return callback(err);//如果出错
        if(stats.isFile()) return callback(null,stats.size);//如果是文件

        fs.readdir(dir,function(err,files){//如果是目录
            if(err) return callback(err);//如果遍历目录出错
            if(files.length==0) return callback(null,0);//如果目录是空的

            var count = files.length;//哨兵变量
            for(var i = 0;i<files.length;i++){
                getdirsize(path.join(dir,files[i]),function(err,_size){
                    if(err) return callback(err);
                    size+=_size;
                    if(--count<=0){//如果目录中所有文件(或目录)都遍历完成
                        callback(null,size);
                    }
                });
            }
        });
    });
}

var walk = function(dir, done) {
    //var results = [];
    var size = 0;
    fs.readdir(dir, function(err, list) {
        if (err) return done(err);
        var pending = list.length;
        if (!pending) return done(null, size);
        list.forEach(function(file) {
            file = path.resolve(dir, file);
            fs.stat(file, function(err, stat) {
                if (stat && stat.isDirectory()) {
                    walk(file, function(err, res) {
                        size = size+res;
                        if (!--pending) done(null, size);
                    });
                } else {
                    size = size+stat.size;
                    if (!--pending) done(null, size);
                }
            });
        });
    });
};