Jak napisać plik, jeśli folder nadrzędny nie istnieje?

Muszę zapisać plik do następującej ścieżki:

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

Ale '/folder1/folder2'ścieżka może nie istnieć. Więc otrzymuję następujący błąd:

message = ENOENT, otwórz /folder1/folder2/file.txt

Jak mogę napisać treść na tej ścieżce?

Użyj mkdirp w połączeniu z 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);
  });
}

Jeśli cała ścieżka już istnieje, mkdirpjest noop. W przeciwnym razie tworzy dla Ciebie wszystkie brakujące katalogi.

Ten moduł robi, co chcesz: https://npmjs.org/package/writefile . Rozumiem, szukając w Google hasła „writefile mkdirp”. Ten moduł zwraca obietnicę zamiast odbierania wywołania zwrotnego, więc najpierw przeczytaj wprowadzenie do obietnic. W rzeczywistości może to skomplikować sprawę.

Funkcja, którą podałem, działa w każdym przypadku.

Uważam, że najłatwiejszym sposobem jest użycie metody outputFile () z modułu fs-extra .

Prawie to samo, co writeFile (tj. Nadpisuje), z tym wyjątkiem, że jeśli katalog nadrzędny nie istnieje, zostaje utworzony. opcje są tym, co można przekazać do fs.writeFile ().

Przykład:

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

W dzisiejszych czasach ma również obiecujące wsparcie po wyjęciu z pudełka!

Edytować

Wersja NodeJS 10.12.0dodała natywną obsługę obu mkdiri mkdirSyncrekurencyjne tworzenie nadrzędnego reżysera z następującą recursive: trueopcją:

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

A jeśli wolisz fs Promises API, możesz pisać

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

Oryginalna odpowiedź

Utwórz katalogi nadrzędne rekurencyjnie, jeśli nie istnieją! ( Zero zależności )

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

Stosowanie

// 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');

Próbny

Spróbuj!

Wyjaśnienia

• [UPDATE] Błędy Ta platforma uchwyty rozwiązanie specyficzne jak EISDIRdla Mac i EPERMi EACCESdla Windows.
• To rozwiązanie obsługuje zarówno ścieżki względne, jak i bezwzględne .
• W przypadku ścieżek względnych katalogi docelowe zostaną utworzone (rozwiązane) w bieżącym katalogu roboczym. Aby rozwiązać je w odniesieniu do bieżącego katalogu skryptowego, pass {isRelativeToScript: true}.
• Używanie path.sepi path.resolve(), a nie tylko /konkatenacja, w celu uniknięcia problemów między platformami.
• Używanie fs.mkdirSynci obsługa błędu za pomocą try/catchif zgłoszonego w celu obsługi warunków wyścigu: inny proces może dodać plik między wywołaniami do fs.existsSync()i fs.mkdirSync()i powoduje wyjątek.
  • Innym sposobem na osiągnięcie tego może być sprawdzenie, czy plik istnieje, a następnie utworzenie go, tj if (!fs.existsSync(curDir) fs.mkdirSync(curDir);. Ale jest to anty-wzorzec, który pozostawia kod podatny na warunki wyścigu.
• Wymaga Node v6 i nowszych do obsługi destrukturyzacji. (Jeśli masz problemy z wdrożeniem tego rozwiązania w starszych wersjach Node, po prostu zostaw komentarz)

Być może najprościej można po prostu użyć modułu npm fs-path .

Twój kod wyglądałby wtedy następująco:

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

Możesz użyć

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

statsto fs.Statsrodzaj obiektu, możesz sprawdzić stats.isDirectory(). W zależności od zbadania erri statsmożna coś zrobić fs.mkdir( ... )lub wyrzucić błąd.

Odniesienie

Aktualizacja: Poprawiono przecinki w kodzie.

Dzięki node-fs-extra możesz to łatwo zrobić.

Zainstaluj to

npm install --save fs-extra

Następnie użyj outputfile metodę zamiast 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!');
  }
})

Oto moja niestandardowa funkcja do rekurencyjnego tworzenia katalogów (bez zewnętrznych zależności):

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

Oto moja funkcja, która działa w Node 10.12.0. Mam nadzieję, że to pomoże.

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

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

Oto część odpowiedzi Myrne Stol podzielona jako osobna odpowiedź:

Ten moduł robi, co chcesz: https://npmjs.org/package/writefile . Rozumiem, szukając w Google hasła „writefile mkdirp”. Ten moduł zwraca obietnicę zamiast odbierania wywołania zwrotnego, więc najpierw przeczytaj wprowadzenie do obietnic. W rzeczywistości może to skomplikować sprawę.