Question

DEFINITION

File#createDirectoriesFromJSON (json, cb);

json：JSON对象。

cb：功能。参数：error（Error），created（布尔值，如果至少创建了一个目录，则为true）。

假设File类包含一个名为_path的属性，该属性包含目录的路径。

的 USAGE

var json = {
    b: {
        c: {
            d: {},
            e: {}
        },
        f: {}
    },
    g: {
        h: {}
    }
};

//this._path = "."
new File (".").createDirectoriesFromJSON (json, function (error, created){
    console.log (created); //Prints: true

    //callback binded to the File instance (to "this"). Hint: cb = cb.bind (this)
    this.createDirectoriesFromJSON (json, function (error, created){
        console.log (created); //Prints: false (no directory has been created)
    });
});

的 RESULT

在“。”下已经创建了json对象中显示的目录树。

./ B / C / d
  ./b/c/e
  ./b/f
  ./b/g/h

的实施

这就是我没有 async.js：

File.prototype.createDirectoriesFromJSON = function (json, cb){
    cb = cb.bind (this);

    var created = false;
    var exit = false;

    var mkdir = function (path, currentJson, callback){
        var keys = Object.keys (currentJson);
        var len = keys.length;
        var done = 0;

        if (len === 0) return callback (null);

        for (var i=0; i<len; i++){
            (function (key, i){
                var dir = PATH.join (path, key);
                FS.mkdir (dir, function (mkdirError){
                    exit = len - 1 === i;

                    if (mkdirError && mkdirError.code !== "EEXIST"){
                        callback (mkdirError);
                        return;
                    }else if (!mkdirError){
                        created = true;
                    }

                    mkdir (dir, currentJson[key], function (error){
                        if (error) return callback (error);
                        done++;
                        if (done === len){
                            callback (null);
                        }
                    });
                });
            })(keys[i], i);
        }
    };

    var errors = [];

    mkdir (this._path, json, function (error){
        if (error) errors.push (error);
        if (exit){
            errors = errors.length === 0 ? null : errors;
            cb (errors, errors ? false : created);
        }
    });
};

出于好奇，我想用async.js重写函数。这里的问题是函数是递归和并行的。例如，“b”文件夹与“g”并行创建。 “b / c”和“b / f”，“b / c / d”和“b / c / e”相同。

Answer 1

我的尝试：

var _path  = require('path');
var _fs    = require('fs');
var _async = require('async');

function File() {
    this._path = __dirname + '/test';
}

File.prototype.createDirectoriesFromJSON = function(json, cb) {
    var created = [], errors  = [];

    function iterator(path, currentJson, key, fn){
        var dir = _path.join(path, key);

        _fs.mkdir(dir, function(mkdirError) {

            if(mkdirError && mkdirError.code !== "EEXIST") {
                errors.push(mkdirError);
            } else if(!mkdirError) {
                created.push(dir);
            }

            mkdir(dir, currentJson[key], fn);
        });
    }

    function mkdir(path, currentJson, callback) {
        var keys = Object.keys(currentJson);

        if(keys.length === 0) return callback(null);

        _async.forEach(keys, iterator.bind(this, path, currentJson), callback);
    }

    mkdir(this._path, json, cb.bind(this, errors, created));
};


new File().createDirectoriesFromJSON({
    b: {
        c: {
            d: {},
            e: {}
        },
        f: {}
    },
    g: {
        h: {}
    }
}, function(errors, successes) {
    // errors is an array of errors
    // successes is an array of successful directory creation
    console.log.apply(console, arguments);
});

经过测试：

$ rm -rf test/* && node test.js && tree test

[] [ '/Users/fg/Desktop/test/b',
  '/Users/fg/Desktop/test/g',
  '/Users/fg/Desktop/test/b/c',
  '/Users/fg/Desktop/test/b/f',
  '/Users/fg/Desktop/test/g/h',
  '/Users/fg/Desktop/test/b/c/d',
  '/Users/fg/Desktop/test/b/c/e' ] null
test
|-- b
|   |-- c
|   |   |-- d
|   |   `-- e
|   `-- f
`-- g
    `-- h

7 directories, 0 files

注意：

由于errors.push(mkdirError);表示无法创建目录，因此可以附加return fn(null);以停止从此分支创建目录。
cb将收到第三个参数，该参数始终为null。
我最好使用wrench .mkdirSyncRecursive()来执行此类任务，或者将asack as mkdirp替换。

[更新] 使用mkdirp和lodash（或下划线）代码可以更清晰：

var _path   = require('path');
var _fs     = require('fs');

var _async  = require('async');
var _mkdirp = require('mkdirp');
var _       = require('lodash'); // or underscore

function File() {
    this._path = __dirname + '/test';
}

File.prototype.flattenJSON = function(json){
    function walk(path, o, dir){
        var subDirs = Object.keys(o[dir]);
        path +=  '/' + dir;

        if(subDirs.length === 0){
            return path;
        }

        return subDirs.map(walk.bind(null, path, o[dir]));
    }

    return _.flatten(Object.keys(json).map(walk.bind(null, this._path, json)));
};

File.prototype.createDirectoriesFromJSON = function(json, cb) {
    var paths   = this.flattenJSON(json)
    ,   created = []
    ,   errors  = [];

    function iterator(path, fn){
        _mkdirp(path, function(mkdirError) {

            if(mkdirError && mkdirError.code !== "EEXIST") {
                errors.push(mkdirError);
            } else if(!mkdirError) {
                created.push(path);
            }

            return fn(null);
        });
    }

    _async.forEach(paths, iterator, cb.bind(this, errors, created));
};


new File().createDirectoriesFromJSON({
    b: {
        c: {
            d: {},
            e: {}
        },
        f: {}
    },
    g: {
        h: {}
    }
}, function(errors, successes) {
    // errors is an array of error
    // successes is an array of successful directory creation
    console.log.apply(console, arguments);
});

经过测试：

$ rm -rf test/* && node test2.js && tree test

[] [ '/Users/fg/Desktop/test/b/f',
  '/Users/fg/Desktop/test/g/h',
  '/Users/fg/Desktop/test/b/c/d',
  '/Users/fg/Desktop/test/b/c/e' ] null
test
|-- b
|   |-- c
|   |   |-- d
|   |   `-- e
|   `-- f
`-- g
    `-- h

7 directories, 0 files

注意：

iterator可以通过使用部分函数应用程序删除，但是下划线/ lodash只支持从左到右的部分，因此我不想要另一个库这样做。

Answer 2

不知道它是否是最佳解决方案，但我过去通过创建一个额外的“监视器”类型对象来解决这个问题。简而言之，将初始化更改为：

var monitor = {
    var init = function(json, cb) {
        this.outerDirLength = Object.keys (currentJson);
        this.processedOuterDirs = 0; //track 'report progress'  calls
        this.completedOuterDirs = 0; //'report progress' calls with no errors = success
        this.errors = [];
        this.finishedCallback = cb;
    }
    var reportProgress = function(error) {
        this.processedOuterDirs++;
        if (error) this.errors.push(error);
        else this.completedOuterDirs++;
        if (this.isComplete()) this.finish();
    }
    var finish = function () {
        var errors = this.errors.length === 0 ? null : this.errors;
        this.finishedCallback(errors, errors ? false : this.completedOuterDirs);
    }
    var isComplete = function() {
        return this.processedOuterDirs == this.outerDirLength;
    }
};
monitor.init(json, cb);
if (monitor.isComplete()) {
    //handle case of JSON with zero definitions
    monitor.finish();
    return;
}
mkdir (this._path, json, function (error){
    monitor.reportProgress(error);
});

请注意，上面的内容尚未经过测试（甚至是经过测试编译），但是应该给你一个想法......如果你要使 mkdir 真正异步，你可能会改变上面的内容因此，在每次调用 mkdir 时，它会计算要创建的目标数量，并在监视器上增加预期目标，然后在创建每个目标时更新监视器。

从多级JSON递归创建目录（使用async.js）

2 个答案: