Writing files in Node.js

There are a lot of details in the filesystem API. The most common way (as far as I know) is:

var fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
}); 

Currently there are 3 ways to write a file:

1. fs.write(fd, buffer, offset, length, position, [callback])

   You need to wait for the callback to ensure that the buffer is written to disk. It's not buffered.

2. fs.writeFile(filename, data, [encoding], [callback])

   All data must be stored at the same time; you cannot perform sequential writes.

3. fs.createWriteStream(path, [options])

   Creates a WriteStream, which is convenient because you don't need to wait for a callback. But again, it's not buffered.

A WriteStream, as the name says, is a stream. A stream by definition is “a buffer” containing data which moves in one direction (source ► destination). But a writable stream is not necessarily “buffered”. A stream is “buffered” when you write n times, and at time n+1, the stream sends the buffer to the kernel (because it's full and needs to be flushed).

In other words: “A buffer” is the object. Whether or not it “is buffered” is a property of that object.

If you look at the code, the WriteStream inherits from a writable Stream object. If you pay attention, you’ll see how they flush the content; they don't have any buffering system.

If you write a string, it’s converted to a buffer, and then sent to the native layer and written to disk. When writing strings, they're not filling up any buffer. So, if you do:

write("a")
write("b")
write("c")

You're doing:

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

That’s 3 calls to the I/O layer. Although you're using “buffers”, the data is not buffered. A buffered stream would do: fs.write(new Buffer ("abc")), 1 call to the I/O layer.

As of now in Node v0.12 (stable version announced 02/06/2015) now supports 2 functions: cork() and uncork(). It seems that these functions will finally allow you to buffer/flush the write calls.

For example, in Java there are some classes that provide buffered streams (BufferedOutputStream, BufferedWriter...). If you write 3 bytes, these bytes will be stored in the buffer (memory) instead of doing an I/O call just for 3 bytes. When the buffer is full the content it’s flushed and saved to disk. This improves performance.

I'm not discovering anything, just remembering how a disk access should be done.

You can of course make it a little more advance. Non blocking, writing bits and pieces, not writing the whole file at once.

var fs = require('fs');
var stream = fs.createWriteStream("my_file.txt");
stream.once('open', function(fd) {
  stream.write("My first row\n");
  stream.write("My second row\n");
  stream.end();
});

var path = 'public/uploads/file.txt',
buffer = new Buffer("some content\n");

fs.open(path, 'w', function(err, fd) {
    if (err) {
        throw 'error opening file: ' + err;
    }

    fs.write(fd, buffer, 0, buffer.length, null, function(err) {
        if (err) throw 'error writing file: ' + err;
        fs.close(fd, function() {
            console.log('file written');
        })
    });
});

I liked this link :

https://docs.nodejitsu.com/articles/file-system

it worked for me

https://docs.nodejitsu.com/articles/file-system/how-to-write-files-in-nodejs

fs = require('fs');
fs.writeFile('helloworld.txt', 'Hello World!', function (err) {
  if (err) return console.log(err);
  console.log('Hello World > helloworld.txt');
});

[contents of helloworld.txt]: Hello World!

Here use w+ is for read/write both action and if file path not found that would be created automatic.

fs.open(path, 'w+', function(err, data) {
if (err) {
    console.log("ERROR !! " +err);
} else {
    fs.write(data, 'content', 0, 'content length', null, function(err) {
        if (err) console.log("ERROR !! " +err);
        fs.close(data, function() {
            console.log('written success');
        })
    });
}
});

Content means what you have to write in file and it's length 'content.length'