¿Cómo escribir un archivo si la carpeta principal no existe?

Necesito escribir el archivo en la siguiente ruta:

fs.writeFile('/folder1/folder2/file.txt', 'content', function () {…});

Pero el '/folder1/folder2'camino puede no existir. Entonces obtengo el siguiente error:

mensaje = ENOENT, abra /folder1/folder2/file.txt

¿Cómo puedo escribir contenido en esa ruta?

Utilice mkdirp en combinación con path.dirnamefirst.

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

Si todo el camino ya existe, mkdirpes un error. De lo contrario, crea todos los directorios que faltan.

Este módulo hace lo que quiere: https://npmjs.org/package/writefile . Lo entendí al buscar en Google "writefile mkdirp". Este módulo devuelve una promesa en lugar de recibir una devolución de llamada, así que asegúrese de leer primero una introducción a las promesas. De hecho, podría complicarte las cosas.

La función que le di funciona en cualquier caso.

Encuentro que la forma más fácil de hacer esto es usar el método outputFile () del módulo fs-extra .

Casi lo mismo que writeFile (es decir, se sobrescribe), excepto que si el directorio principal no existe, se crea. las opciones son las que pasaría a fs.writeFile ().

Ejemplo:

var fs = require('fs-extra');
var file = '/tmp/this/path/does/not/exist/file.txt'

fs.outputFile(file, 'hello!', function (err) {
    console.log(err); // => null

    fs.readFile(file, 'utf8', function (err, data) {
        console.log(data); // => hello!
    });
});

¡También tiene soporte prometedor listo para usar en estos días!

Quizás lo más simple es que puede usar el módulo npm fs-path .

Su código se vería así:

var fsPath = require('fs-path');

fsPath.writeFile('/folder1/folder2/file.txt', 'content', function(err){
  if(err) {
    throw err;
  } else {
    console.log('wrote a file like DaVinci drew machines');
  }
});

Editar

La versión de NodeJS 10.12.0ha agregado un soporte nativo para ambos mkdiry mkdirSyncpara crear el director principal de forma recursiva con recursive: truela siguiente opción:

fs.mkdirSync(targetDir, { recursive: true });

Y si lo prefieres fs Promises APIpuedes escribir

fs.promises.mkdir(targetDir, { recursive: true });

Respuesta original

¡Cree los directorios principales de forma recursiva si no existen! ( Cero dependencias )

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

function mkDirByPathSync(targetDir, { isRelativeToScript = false } = {}) {
  const sep = path.sep;
  const initDir = path.isAbsolute(targetDir) ? sep : '';
  const baseDir = isRelativeToScript ? __dirname : '.';

  return targetDir.split(sep).reduce((parentDir, childDir) => {
    const curDir = path.resolve(baseDir, parentDir, childDir);
    try {
      fs.mkdirSync(curDir);
    } catch (err) {
      if (err.code === 'EEXIST') { // curDir already exists!
        return curDir;
      }

      // To avoid `EISDIR` error on Mac and `EACCES`-->`ENOENT` and `EPERM` on Windows.
      if (err.code === 'ENOENT') { // Throw the original parentDir error on curDir `ENOENT` failure.
        throw new Error(`EACCES: permission denied, mkdir '${parentDir}'`);
      }

      const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1;
      if (!caughtErr || caughtErr && curDir === path.resolve(targetDir)) {
        throw err; // Throw if it's just the last created dir.
      }
    }

    return curDir;
  }, initDir);
}

Uso

// Default, make directories relative to current working directory.
mkDirByPathSync('path/to/dir');

// Make directories relative to the current script.
mkDirByPathSync('path/to/dir', {isRelativeToScript: true});

// Make directories with an absolute path.
mkDirByPathSync('/path/to/dir');

Manifestación

¡Intentalo!

Explicaciones

• [ACTUALIZACIÓN] errores Esta manijas de soluciones de plataformas específicas como EISDIRpara Mac y EPERMy EACCESpara Windows.
• Esta solución maneja rutas relativas y absolutas .
• En el caso de rutas relativas, los directorios de destino se crearán (resolverán) en el directorio de trabajo actual. Para resolverlos en relación con el directorio de script actual, pase {isRelativeToScript: true}.
• Usar path.sepy path.resolve(), no solo /concatenación, para evitar problemas multiplataforma.
• El uso fs.mkdirSyncy manejo del error con try/catchsi se tiran para manejar las condiciones de carrera: otro proceso puede agregar el archivo entre las llamadas a fs.existsSync()y fs.mkdirSync()y provoca una excepción.
  • La otra manera de lograr que se podría comprobar si un archivo existe, entonces la creación de ella, es decir, if (!fs.existsSync(curDir) fs.mkdirSync(curDir);. Pero este es un anti-patrón que deja al código vulnerable a las condiciones de carrera.
• Requiere Node v6 y más reciente para admitir la desestructuración. (Si tiene problemas para implementar esta solución con versiones antiguas de Node, déjeme un comentario)

Puedes usar

fs.stat('/folder1/folder2', function(err, stats){ ... });

statses un fs.Statstipo de objeto, puedes comprobarlo stats.isDirectory(). Dependiendo del examen de erry statspuedes hacer algo,fs.mkdir( ... ) o arrojar un error.

Referencia

Actualización: se corrigieron las comas en el código.

Aquí está mi función personalizada para crear directorios de forma recursiva (sin dependencias externas):

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

var myMkdirSync = function(dir){
    if (fs.existsSync(dir)){
        return
    }

    try{
        fs.mkdirSync(dir)
    }catch(err){
        if(err.code == 'ENOENT'){
            myMkdirSync(path.dirname(dir)) //create parent dir
            myMkdirSync(dir) //create dir
        }
    }
}

myMkdirSync(path.dirname(filePath));
var file = fs.createWriteStream(filePath);

Aquí está mi función que funciona en el nodo 10.12.0. Espero que esto ayude.

const fs = require('fs');
function(dir,filename,content){
        fs.promises.mkdir(dir, { recursive: true }).catch(error => { console.error('caught exception : ', error.message); });
        fs.writeFile(dir+filename, content, function (err) {
            if (err) throw err;
            console.info('file saved!');
        });
    }

Con node-fs-extra puedes hacerlo fácilmente.

Instalarlo

npm install --save fs-extra

A continuación, utilice la OutputFile método en lugar de writeFileSync

const fs = require('fs-extra');

fs.outputFile('tmp/test.txt', 'Hey there!', err => {
  if(err) {
    console.log(err);
  } else {
    console.log('The file was saved!');
  }
})

Aquí hay parte de la respuesta de Myrne Stol desglosada como una respuesta separada:

Este módulo hace lo que quiere: https://npmjs.org/package/writefile . Lo entendí al buscar en Google "writefile mkdirp". Este módulo devuelve una promesa en lugar de recibir una devolución de llamada, así que asegúrese de leer primero una introducción a las promesas. De hecho, podría complicarte las cosas.

let name = "./new_folder/" + file_name + ".png";
await driver.takeScreenshot().then(
  function(image, err) {
    require('mkdirp')(require('path').dirname(name), (err) => {
      require('fs').writeFile(name, image, 'base64', function(err) {
        console.log(err);
      });
    });
  }
);