CODEWITHSUNDEEP
javascriptnode.jsasync-awaitfs
Quellenangeber
Quellenangeber

Reputation: 2321

Using filesystem in node.js with async / await

I would like to use async/await with some filesystem operations. Normally async/await works fine because I use babel-plugin-syntax-async-functions.

But with this code I run into the if case where names is undefined:

import fs from 'fs';

async function myF() {
  let names;
  try {
    names = await fs.readdir('path/to/dir');
  } catch (e) {
    console.log('e', e);
  }
  if (names === undefined) {
    console.log('undefined');
  } else {
    console.log('First Name', names[0]);
  }
}

myF();

When I rebuild the code into the callback hell version everything is OK and I get the filenames. Thanks for your hints.

Upvotes: 232

Views: 303985

Answers (12)

bman
bman

Reputation: 5235

Native support for async/await fs functions since Node 11

Since Node.js 11.0.0 (stable), and 10.0.0 (experimental), you can access file system methods already promisify'd. Thanks to promises you can simply use try catch to handle exceptions instead of checking if the callback's returned value contains an error.

The API is very clean and elegant! Simply import file system methods from fs/promises instead of importing them directly from fs:

import fs from 'fs/promises'

async function listDir() {
  try {
    return await fs.readdir('path/to/dir')
  } catch (err) {
    console.error('Error occurred while reading directory:', err)
  }
}

listDir()

Upvotes: 248

AmirabbasGhasemi
AmirabbasGhasemi

Reputation: 309

you can use this code :

fs.promises.readdir(path)

// If promise resolved and
// data are fetched
.then(filenames => {
    for (let filename of filenames) {
        console.log(filename)
    }
})

// If promise is rejected
.catch(err => {
    console.log(err)
})

Upvotes: 3

Yoan Arnaudov
Yoan Arnaudov

Reputation: 4134

You can use the simple and lightweight module https://github.com/nacholibre/nwc-l it supports both async and sync methods.

Note: this module was created by me.

Upvotes: 0

Dan Starns
Dan Starns

Reputation: 3825

As of v10.0, you can use fs.Promises

Example using readdir

const { promises: fs } = require("fs");

async function myF() {
    let names;
    try {
        names = await fs.readdir("path/to/dir");
    } catch (e) {
        console.log("e", e);
    }
    if (names === undefined) {
        console.log("undefined");
    } else {
        console.log("First Name", names[0]);
    }
}

myF();

Example using readFile

const { promises: fs } = require("fs");

async function getContent(filePath, encoding = "utf-8") {
    if (!filePath) {
        throw new Error("filePath required");
    }

    return fs.readFile(filePath, { encoding });
}

(async () => {
    const content = await getContent("./package.json");

    console.log(content);
})();

Upvotes: 77

Konrad
Konrad

Reputation: 7198

Node v14.0.0 and above

you can just do:

import { readdir } from "fs/promises";

just like you would import from "fs"

see this PR for more details: https://github.com/nodejs/node/pull/31553

Upvotes: 22

HKTonyLee
HKTonyLee

Reputation: 3300

This is the TypeScript version to the question. It is usable after Node 11.0:

import { promises as fs } from 'fs';

async function loadMonoCounter() {
    const data = await fs.readFile('monolitic.txt', 'binary');
    return Buffer.from(data);
}

Upvotes: 20

Azbykov
Azbykov

Reputation: 1833

Starting with node 8.0.0, you can use this:

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

const readdir = util.promisify(fs.readdir);

async function myF() {
  let names;
  try {
    names = await readdir('path/to/dir');
  } catch (err) {
    console.log(err);
  }
  if (names === undefined) {
    console.log('undefined');
  } else {
    console.log('First Name', names[0]);
  }
}

myF();

See https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original

Upvotes: 180

dimpiax
dimpiax

Reputation: 12667

Node.js 8.0.0

Native async / await

Promisify

From this version, you can use native Node.js function from util library.

const fs = require('fs')
const { promisify } = require('util')

const readFileAsync = promisify(fs.readFile)
const writeFileAsync = promisify(fs.writeFile)

const run = async () => {
  const res = await readFileAsync('./data.json')
  console.log(res)
}

run()

Promise Wrapping

const fs = require('fs')

const readFile = (path, opts = 'utf8') =>
  new Promise((resolve, reject) => {
    fs.readFile(path, opts, (err, data) => {
      if (err) reject(err)
      else resolve(data)
    })
  })

const writeFile = (path, data, opts = 'utf8') =>
  new Promise((resolve, reject) => {
    fs.writeFile(path, data, opts, (err) => {
      if (err) reject(err)
      else resolve()
    })
  })

module.exports = {
  readFile,
  writeFile
}

...


// in some file, with imported functions above
// in async block
const run = async () => {
  const res = await readFile('./data.json')
  console.log(res)
}

run()

Advice

Always use try..catch for await blocks, if you don't want to rethrow exception upper.

Upvotes: 110

grigson
grigson

Reputation: 3726

I have this little helping module that exports promisified versions of fs functions

const fs = require("fs");
const {promisify} = require("util")

module.exports = {
  readdir: promisify(fs.readdir),
  readFile: promisify(fs.readFile),
  writeFile: promisify(fs.writeFile)
  // etc...
};

Upvotes: 8

sean2078
sean2078

Reputation: 5440

Recommend using an npm package such as https://github.com/davetemplin/async-file, as compared to custom functions. For example: 

import * as fs from 'async-file';

await fs.rename('/tmp/hello', '/tmp/world');
await fs.appendFile('message.txt', 'data to append');
await fs.access('/etc/passd', fs.constants.R_OK | fs.constants.W_OK);

var stats = await fs.stat('/tmp/hello', '/tmp/world');

Other answers are outdated

Upvotes: 5

Alexander Kachkaev
Alexander Kachkaev

Reputation: 912

Here is what worked for me:

const fsp = require('fs-promise');

(async () => {
  try {
    const names = await fsp.readdir('path/to/dir');
    console.log(names[0]);
  } catch (e) {
    console.log('error: ', e);
  }
})();

This code works in node 7.6 without babel when harmony flag is enabled: node --harmony my-script.js. And starting with node 7.7, you don't even need this flag!

The fsp library included in the beginning is just a promisified wrapper for fs (and fs-ext).

I’m really exited about what you can do in node without babel these days! Native async/await make writing code such a pleasure!

UPDATE 2017-06: fs-promise module was deprecated. Use fs-extra instead with the same API.

Upvotes: 5

wursttheke
wursttheke

Reputation: 491

You might produce the wrong behavior because the File-Api fs.readdir does not return a promise. It only takes a callback. If you want to go with the async-await syntax you could 'promisify' the function like this:

function readdirAsync(path) {
  return new Promise(function (resolve, reject) {
    fs.readdir(path, function (error, result) {
      if (error) {
        reject(error);
      } else {
        resolve(result);
      }
    });
  });
}

and call it instead:

names = await readdirAsync('path/to/dir');

Upvotes: 49

Related Questions