Quiz: NodeJS IO Mastery

Buffer.alloc(size) creates a new Buffer of specified size filled with zeros. The output will be: <Buffer 00 00 00 00 00>

If you want to create a Buffer with random data, use Buffer.allocUnsafe(5).

Learn more about Buffer allocation

The numbers in the array represent ASCII codes:

• 65: ‘A’

toString() converts these bytes to their string representation using UTF-8 encoding by default.

Learn more about Buffer encoding

Since readFile is asynchronous, the code continues executing while the file is being read. Therefore, “Done” will be printed before the file content.

To wait for the file to be read first, you could use the Promise-based version:

import { promises as fs } from 'fs';

async function read() {
  const data = await fs.readFile('test.txt', 'utf8');
  console.log(data);
  console.log('Done');
}

fs.readFileSync() returns a Buffer by default when no encoding is specified. If you want a string, you need to either:

1. Specify an encoding: fs.readFileSync('test.txt', 'utf8')
2. Convert the Buffer: content.toString()

Learn more about fs.readFileSync on Node.js docs

Readable streams emit several important events:

• ‘data’: When data is available to be read
• ‘end’: When there is no more data to read
• ‘error’: When an error occurs
• ‘finish’: When all data has been flushed to the underlying system

const readable = fs.createReadStream('file.txt');
readable.on('data', chunk => console.log(chunk));
readable.on('end', () => console.log('Done!'));

Learn more about Stream events

pipe() connects a readable stream to a writable stream, automatically managing backpressure and copying data in chunks without loading the entire file into memory.

This is memory-efficient for large files compared to fs.readFile() followed by fs.writeFile().

Learn more about pipe()

The recursive: true option creates parent directories if they don’t exist. Without this option, trying to create ‘./a/b/c’ would throw an error if ‘./a’ or ‘./a/b’ don’t exist.

This is similar to the shell command mkdir -p.

Learn more about mkdir

Transform streams modify data as it passes through. Here, each chunk is:

1. Converted to a string
2. Transformed to uppercase
3. Passed to stdout

This creates a pipeline that converts all input to uppercase.

Learn more about Transform streams

fs.watch() often fires twice for a single change because many text editors:

1. Save to a temporary file
2. Rename it to the target file

For more reliable watching, consider using:

• The chokidar package
• Debouncing the callback
• Using fs.watchFile() (though it’s less efficient)

Learn more about fs.watch()

Buffers are compared by reference, not value. Even though they contain the same data, they are different objects.

To compare Buffer contents, use:

buf1.equals(buf2)  // true
// or
Buffer.compare(buf1, buf2) === 0  // true

Learn more about Buffer comparison

Backpressure is a mechanism that prevents memory overflow by pausing reading when the writing end can’t keep up.

Example of manual backpressure:

readable.on('data', (chunk) => {
  const canContinue = writable.write(chunk);
  if (!canContinue) {
    readable.pause();
    writable.once('drain', () => readable.resume());
  }
});

pipe() handles this automatically!

Learn more about backpressure

symlinkSync creates a symbolic link (like a shortcut) to the target file.

Key differences from hard links:

• Can link to directories
• Can span file systems
• Breaks if target is deleted

To create a hard link instead:

fs.linkSync('target.txt', 'hardlink.txt');

Learn more about symlinks

Streams can operate in:

1. Binary mode (default): for buffers and strings
2. Object mode: for any JavaScript value

Example of object mode:

import { Transform } from 'stream';
const objectStream = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    callback(null, { value: chunk });
  }
});

Learn more about stream modes

File descriptors are numbers that uniquely identify open files in the operating system.

The first three file descriptors are reserved:

• 0: stdin
• 1: stdout
• 2: stderr

Always remember to close file descriptors:

fs.close(fd, (err) => {
  if (err) throw err;
});

Learn more about file descriptors

In UTF-8:

• ASCII characters (like ‘Hello ’) take 1 byte each
• The earth emoji 🌍 takes 4 bytes

So: 5 (Hello) + 1 (space) + 4 (🌍) = 10 bytes

To see the bytes:

console.log(buf);  // <Buffer 48 65 6c 6c 6f 20 f0 9f 8c 8d>

Learn more about UTF-8 encoding