1

定义

File#createDirectoriesFromJSON (json, cb);

json：JSON 对象。

CB：功能。参数：error（错误）、created（布尔值，如果至少创建了一个目录则为真）。

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


用法

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)
    });
});


结果

在下面 ”。” 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”也是一样的。

4

2 回答 2

4

我的尝试：

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或 substack async mkdirp。.mkdirSyncRecursive()

[更新]使用 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 仅支持从左到右的部分，因此我不想要求另一个库这样做。
于 2012-10-28T09:56:26.087 回答
0

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

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开始时它计算要创建多少个目录，并在监视器上增加预期目标，然后在创建每个目录时更新监视器。

于 2012-10-27T11:25:02.303 回答