Question

如果文件位于可能存在或不存在的目录中，如何使用nodejs编写文件？

有点类似于这个问题：

只有我需要一个创建文件的解决方案，而node-fs只生成目录。

Answer 1

修改功能以满足您的需求！但严重的是，使用模块而不是编写自己的模块！

createDirectory()：创建一个目录。如果不存在构成路径的任何先前目录，则会创建它们。默认权限：0777。

File.prototype.createDirectory = function (cb){
    if (cb) cb = cb.bind (this);
    if (!this._path){
        if (cb) cb (NULL_PATH_ERROR, false);
        return;
    }
    if (!canWriteSM (this._usablePath)){
        if (cb) cb (SECURITY_WRITE_ERROR, false);
        return;
    }

    var mkdirDeep = function (path, cb){
        path.exists (function (exists){
            if (exists) return cb (null, false);

            FS.mkdir (path.getPath (), function (error){
                if (!error) return cb (null, true);

                var parent = path.getParentFile ();
                if (parent === null) return cb (null, false);

                mkdirDeep (parent, function (error, created){
                    if (created){
                        FS.mkdir (path.getPath (), function (error){
                            cb (error, !error);
                        });
                    }else{
                        parent.exists (function (exists){
                            if (!exists) return cb (null, false);

                            FS.mkdir (path.getPath (), function (error){
                                cb (error, !error);
                            });
                        });
                    }
                });
            });
        });
    };

    mkdirDeep (this.getAbsoluteFile (), function (error, created){
        if (cb) cb (error, created);
    });
};

createNewFile()：创建一个新文件。默认权限：0666。

File.prototype.createNewFile = function (cb){
    if (cb) cb = cb.bind (this);
    if (!this._path){
        if (cb) cb (NULL_PATH_ERROR, false);
        return;
    }

    if (!canWriteSM (this._usablePath)){
        if (cb) cb (SECURITY_WRITE_ERROR, false);
        return;
    }

    var path = this._usablePath;
    PATH.exists (path, function (exists){
        if (exists){
            if (cb) cb (null, false);
        }else{
            var s = FS.createWriteStream (path);
            s.on ("error", function (error){
                if (cb) cb (error, false);
            });
            s.on ("close", function (){
                if (cb) cb (null, true);
            });
            s.end ();
        }
    });
};

Answer 2

我刚写了这个作为How to write file if parent folder doesn't exist?的答案。对于在谷歌中遇到这种情况的人来说，可能会有用：

首先与mkdirp结合使用path.dirname。

var mkdirp = require("mkdirp")
var fs = require("fs")
var getDirName = require("path").dirname
function writeFile (path, contents, cb) {
  mkdirp(getDirName(path), function (err) {
    if (err) return cb(err)
    fs.writeFile(path, contents, cb)
  })
}

Answer 3

您可以使用类似createWriteStream的内容。

如果文件不存在，它将只创建文件。

Answer 4

由于fs.exists()是deprecated，这里是使用fs.access()的另一个异步版本，而且没有外部的npm模块：

"use strict";
var fs =  require('fs');
var path = require('path');

var fileName = '\\tmp\\a\\b\\c\\d.txt'; // e.g. using Windows path separator
var contents = 'any content';

createDirectoryAndFile(fileName, contents);

function createDirectoryAndFile(fileName, contents) {
  var dirName = path.dirname(fileName);
  var pathAsArray = dirName.split(path.sep);
  _createDirectoryAndFile(pathAsArray, '', function() {
    fs.open(fileName, 'w+', function(error, data) {
      fs.writeFile(fileName, contents, function(error) {});
    });
  });
}

function _createDirectoryAndFile(pathAsArray, pathSoFar, createFile) {
  if (!pathAsArray || pathAsArray.length === 0) {
    createFile();
    return;
  }

  var dir = pathAsArray.shift();
  pathSoFar = pathSoFar + dir  + path.sep;
  fs.access(pathSoFar, function(error) {
    if (error) { // directory does not exist
      fs.mkdir(pathSoFar, function(error) {
        if (!error) {
          _createDirectoryAndFile(pathAsArray, pathSoFar, createFile);
        }
      });
    } else {
      _createDirectoryAndFile(pathAsArray, pathSoFar, createFile);
    }
  });
}

当然，这需要通过添加错误处理和支持权限来改进。

Answer 5

对于TypeScript用户，我刚刚根据doc编写了一个用户：

const _0777 = parseInt('0777', 8);

export function mkdirP(dir: string, opts: {
    fs?: {
        mkdir: (path: string | Buffer, mode: number,
                callback?: (err?: NodeJS.ErrnoException) => void) => void,
        stat: (path: string | Buffer,
               callback?: (err: NodeJS.ErrnoException,
                           stats: fs.Stats) => any) => void
    }, mode?: number}, f: Function, made?) {
    dir = resolve(dir);
    if (typeof opts === 'function') {
        f = <Function>opts;
        opts = {};
    }
    else if (!opts || typeof opts !== 'object')
        opts = {mode: <number>opts};

    opts.mode = opts.mode || (_0777 & (~process.umask()));
    opts.fs = opts.fs || fs;

    if (!made) made = null;

    const cb = f || (() => undefined);

    opts.fs.mkdir(dir, opts.mode, function (error) {
        if (!error) {
            made = made || dir;
            return cb(null, made);
        }
        switch (error.code) {
            case 'ENOENT':
                mkdirP(dirname(dir), opts, function (err, made) {
                    if (err) cb(err, made);
                    else mkdirP(dir, opts, cb, made);
                });
                break;

            default:
                opts.fs.stat(dir, function (e, stat) {
                    if (e || !stat.isDirectory()) cb(error || e, made);
                    else cb(null, made);
                });
        }
    });
}

JavaScript版本只是从签名中删除类型注释，即：将前几行转为：(dir, opts, mode, f, made) {。

Answer 6

// Create parentDir recursively if it doesn't exist!
const parentDir = 'path/to/parent';
parentDir.split('/').forEach((dir, index, splits) => {
  const curParent = splits.slice(0, index).join('/');
  const dirPath = path.resolve(curParent, dir);
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath);
  }
});

// Create file.js inside the parentDir
fs.writeFileSync(`${parentDir}/file.js`, 'file Content', 'utf8');

Answer 7

您可以使用https://github.com/douzi8/file-system

var file = require('file-system');
file.mkdir('1/2/3/4/5', [mode], function(err) {});

node.js递归写文件目录

7 个答案: