javascript - servidor - node.js tutorial

Node.js crea una carpeta o usa una existente

Question

Ya he leído la documentación de Node.js y, a menos que haya pasado algo por alto, no indica qué contienen los parámetros en ciertas operaciones, en particular fs.mkdir() . Como puede ver en la documentación, no es mucho.

Actualmente, tengo este código, que intenta crear una carpeta o usar una existente:

fs.mkdir(path,function(e){
    if(!e || (e && e.code === ''EEXIST'')){
        //do something with contents
    } else {
        //debug
        console.log(e);
    }
});

Pero me pregunto si esta es la forma correcta de hacerlo. ¿Está buscando el código EEXIST la manera correcta para saber que la carpeta ya existe? Sé que puedo hacer fs.stat() antes de hacer el directorio, pero eso ya serían dos visitas al sistema de archivos.

En segundo lugar, ¿existe una documentación completa o al menos más detallada de Node.js que contenga detalles sobre qué objetos de error contienen, qué parámetros significan, etc.

Answer 1

crear un directorio de nombre dinámico para cada usuario ... use este código

***suppose email contain user mail address***

var filessystem = require(''fs'');
var dir = ''./public/uploads/''+email;

if (!filessystem.existsSync(dir)){
  filessystem.mkdirSync(dir);

}else
{
    console.log("Directory already exist");
}

Answer 2

Aquí está el código ES6 que utilizo para crear un directorio (cuando no existe):

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

function createDirectory(directoryPath) {
  const directory = path.normalize(directoryPath);

  return new Promise((resolve, reject) => {
    fs.stat(directory, (error) => {
      if (error) {
        if (error.code === ''ENOENT'') {
          fs.mkdir(directory, (error) => {
            if (error) {
              reject(error);
            } else {
              resolve(directory);
            }
          });
        } else {
          reject(error);
        }
      } else {
        resolve(directory);
      }
    });
  });
}

const directoryPath = `${__dirname}/test`;

createDirectory(directoryPath).then((path) => {
  console.log(`Successfully created directory: ''${path}''`);
}).catch((error) => {
  console.log(`Problem creating directory: ${error.message}`)
});

Nota:

• Al comienzo de la función createDirectory , normalizo la ruta para garantizar que el tipo de separador de ruta del sistema operativo se utilizará de forma coherente (por ejemplo, esto convertirá C:/directory/test en C:/directory/test (cuando esté en Windows) )
• fs.exists está en nodejs.org/api/fs.html#fs_fs_exists_path_callback , es por eso que uso fs.stat para verificar si el directorio ya existe
• Si un directorio no existe, el código de error será ENOENT ( E rror NO ENT ry)
• El directorio en sí se creará usando fs.mkdir
• Prefiero la función asíncrona fs.mkdir sobre su contraparte de bloqueo fs.mkdirSync y, debido a la Promise fs.mkdirSync , se garantizará que la ruta del directorio solo se devolverá después de que el directorio se haya creado correctamente.

Answer 3

Es mejor que no cuentes los hits del sistema de archivos mientras codificas en Javascript, en mi opinión. Sin embargo, (1) stat & mkdir y (2) mkdir y comprueba (o descarta) el código de error, ambas maneras son las correctas para hacer lo que quieres.

Answer 4

Los documentos node.js para fs.mkdir básicamente fs.mkdir a la página man de Linux para mkdir(2) . Eso indica que EEXIST también se indicará si la ruta existe, pero no es un directorio que crea un caso de esquina incómodo si vas por esta ruta.

Puede ser mejor que llame a fs.stat que le dirá si la ruta existe y si es un directorio en una sola llamada. Para (lo que asumo es) el caso normal donde el directorio ya existe, es solo un solo golpe al sistema de archivos.

Estos métodos de módulo fs son envoltorios delgados alrededor de las API C nativas, por lo que debe verificar las páginas man a las que se hace referencia en los documentos node.js para obtener más información.

Answer 5

Puedes usar esto:

if(!fs.existsSync("directory")){
    fs.mkdirSync("directory", 0766, function(err){
        if(err){
            console.log(err);
            // echo the result back
            response.send("ERROR! Can''t make the directory! /n");
        }
    });
}

Answer 6

Recomiendo más simple:

// Get modules node
const fs   = require(''fs'');
const path = require(''path'');

// Create 
function mkdirpath(dirPath)
{
    if(!fs.existsSync(dirPath))
    {
        try
        {
            fs.mkdirSync(dirPath);
        }
        catch(e)
        {
            mkdirpath(path.dirname(dirPath));
            mkdirpath(dirPath);
        }
    }
}

// Create folder path
mkdirpath(''my/new/folder/create'');

Answer 7

Si quieres un trazador de líneas rápido y sucio, utiliza esto:

fs.existsSync("directory") || fs.mkdirSync("directory");

Answer 8

También puede usar fs-extra , que proporciona operaciones de archivo usadas con mucha frecuencia.

Código de muestra:

var fs = require(''fs-extra'')

fs.mkdirs(''/tmp/some/long/path/that/prob/doesnt/exist'', function (err) {
  if (err) return console.error(err)
  console.log("success!")
})

fs.mkdirsSync(''/tmp/another/path'')

documentos aquí: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback

Answer 9

Una buena forma de hacerlo es usar el módulo mkdirp .

$ npm install mkdirp

Úselo para ejecutar la función que requiere el directorio. La devolución de llamada se invoca después de que se crea la ruta o si la ruta ya existe. Error err se establece si mkdirp no pudo crear la ruta del directorio.

var mkdirp = require(''mkdirp'');
mkdirp(''/tmp/some/path/foo'', function(err) { 

    // path exists unless there was an error

});

Answer 10

Usando un try {} catch {} , puedes lograr esto muy elegantemente sin encontrar una condición de carrera:

A fs.mkdirSync(dirPath) fallas fs.mkdirSync(dirPath)

const mkdirSync = function (dirPath) {
  try {
    fs.mkdirSync(dirPath)
  } catch (err) {
    if (err.code !== ''EEXIST'') throw err
  }
}

Nota: dirPath se usa como argumento en lugar de path , como se usa en la documentación oficial de fs.mkdirSync de Node, para evitar confusiones con el módulo de ruta estándar de Node.

Explicación

Nodo intentará crear el directorio y emitirá una excepción si encuentra una excepción al hacerlo. En la cláusula catch {} , continuamos la ejecución del script como si nada hubiera sucedido si el código de error es EEXIST , lo que significa que el directorio existe. Si el código de error no es EEXIST , deberíamos lanzar un error, porque probablemente estamos tratando con una excepción del sistema de archivos como EACCES (permiso denegado).

Debido a que no hay un tiempo muerto entre la comprobación de la existencia y la creación del directorio, evitamos las condiciones de carrera; sin embargo, esto solo puede ser cierto cuando se usa la versión síncrona (por lo que fs.mkdir() no funcionaría), pero las operaciones destructivas del sistema de archivos como mkdir solo deben usarse de forma sincronizada de todos modos.

Editar: Desde entonces, he encontrado una forma de adaptar el mismo concepto al fs.mkdir asíncrono que puedes encontrar en esta esencia mía

Ejemplos

Vamos a crear los directorios ./first/second/third y ./first/second/fourth , dado:

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

const mkdirSync = function (dirPath) {
  try {
    fs.mkdirSync(dirPath)
  } catch (err) {
    if (err.code !== ''EEXIST'') throw err
  }
}

Uso lineal

Con la función envolvente anterior, puede asegurarse de que existen directorios y crearlos de una manera sencilla.

mkdirSync(path.resolve(''./first''))
mkdirSync(path.resolve(''./first/second''))
mkdirSync(path.resolve(''./first/second/third''))
mkdirSync(path.resolve(''./first/second'')) // To demonstrate fault tolerance
mkdirSync(path.resolve(''./first/second/fourth''))

Nota: aún debe asegurarse de que exista cada parte de la ruta del directorio. Llamar a mkdirSync(path.resolve(''./first/second/third'')) directamente sin asegurarse de que ./first y ./first/second existan arrojaría una excepción.

Uso recursivo como mkdir -p UNIX

Con el fin de eludir el inconveniente antes mencionado, puede ajustar aún más nuestro mkdirSync() tolerante a mkdirSync() en una función recursiva que garantizará que cada parte de la ruta exista:

const mkdirpSync = function (dirPath) {
  const parts = dirPath.split(path.sep)

  // For every part of our path, call our wrapped mkdirSync()
  // on the full path until and including that part
  for (let i = 1; i <= parts.length; i++) {
    mkdirSync(path.join.apply(null, parts.slice(0, i)))
  }
}

// You can now directly create the two target directories
mkdirpSync(''first/second/third'')
mkdirpSync(''first/second/fourth'')

Answer 11

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

if (fs.existsSync(''temp'')) 
{

    console.log(''Directory exists, removing...'');
    if (fs.existsSync(''temp/new.txt'')) 
    {
    fs.unlinkSync(''temp/new.txt'');
    }
    fs.rmdirSync(''temp'');

}
fs.mkdirSync(''temp'');
if (fs.existsSync(''temp'')) {
    process.chdir(''temp'');
    fs.writeFileSync(''test.txt'', ''This is some test text for the file'');
    fs.renameSync(''test.txt'',''new.txt'');
    console.log(''File has size: '' + fs.statSync(''new.txt'').size + '' bytes'');
    console.log(''File contents: '' + fs.readFileSync(''new.txt'').toString());
}