stream

---

1. Read from a File:

const fs = require('fs');

const readableStream = fs.createReadStream('file.txt');
readableStream.on('data', (chunk) => {
  console.log(chunk.toString());
});

2. Write to a File:

const fs = require('fs');

const writableStream = fs.createWriteStream('file.txt');
writableStream.write('Hello, world!');

3. Pipe Streams:

const readableStream = fs.createReadStream('file.txt');
const writableStream = fs.createWriteStream('file2.txt');
readableStream.pipe(writableStream);

4. Create a Transform Stream:

const Transform = require('stream').Transform;

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

5. Create a Duplex Stream:

const Duplex = require('stream').Duplex;

const duplexStream = new Duplex({
  read() { /* ... */ },
  write() { /* ... */ }
});

6. Create a Passthrough Stream:

const PassThrough = require('stream').PassThrough;

const passthroughStream = new PassThrough();

7. Use stream.finished:

const readableStream = fs.createReadStream('file.txt');

readableStream.on('finish', () => {
  console.log('File reading complete');
});

8. Use stream.end():

const readableStream = fs.createReadStream('file.txt');

readableStream.end(); // Manually end the stream

9. Use stream.cork() and stream.uncork():

const readableStream = fs.createReadStream('file.txt');

readableStream.cork(); // Buffer writes
readableStream.write('Hello, world!');
readableStream.uncork(); // Flush writes

10. Use stream.setEncoding():

const readableStream = fs.createReadStream('file.txt');

readableStream.setEncoding('utf8');
readableStream.on('data', (chunk) => {
  console.log(chunk); // String data
});

11. Use stream.pause() and stream.resume():

const readableStream = fs.createReadStream('file.txt');

readableStream.pause(); // Pause reading
readableStream.resume(); // Resume reading

12. Destroy a Stream:

const readableStream = fs.createReadStream('file.txt');

readableStream.destroy(); // Close the stream and emit 'end' event

13. Chain Multiple Streams:

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

const readableStream = fs.createReadStream('file.txt');
const gzipStream = zlib.createGzip();
const writableStream = fs.createWriteStream('compressed.txt');

readableStream.pipe(gzipStream).pipe(writableStream);

14. Read from a Database:

const mysql = require('mysql');

const connection = mysql.createConnection({ /* ... */ });
const query = 'SELECT * FROM users';

connection.query(query, (err, rows) => {
  if (err) throw err;

  rows.forEach((row) => {
    console.log(row);
  });
});

15. Write to a Database:

const mysql = require('mysql');

const connection = mysql.createConnection({ /* ... */ });
const query = 'INSERT INTO users (name, age) VALUES (?, ?)';

connection.query(query, ['John', 30], (err, result) => {
  if (err) throw err;

  console.log('User added');
});

16. Send HTTP Requests:

const https = require('https');

const options = {
  hostname: 'example.com',
  port: 443,
  path: '/users',
  method: 'GET'
};

const req = https.request(options, (res) => {
  res.on('data', (data) => {
    console.log(data);
  });
});

req.end();

17. Receive HTTP Responses:

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ success: true }));
});

server.listen(8080);

18. Send Socket.IO Messages:

const socketIO = require('socket.io');

const io = socketIO();
io.on('connection', (socket) => {
  socket.emit('message', 'Hello, world!');
});

19. Receive Socket.IO Messages:

const socketIO = require('socket.io');

const io = socketIO();
io.on('connection', (socket) => {
  socket.on('message', (msg) => {
    console.log(msg);
  });
});

20. Use Readable Streams from Promises:

const fs = require('fs').promises;

async function readFile(file) {
  const data = await fs.readFile(file);
  console.log(data.toString());
}

21. Use Writable Streams from Promises:

const fs = require('fs').promises;

async function writeFile(file, data) {
  await fs.writeFile(file, data);
  console.log('File written');
}

22. Use stream.pipeline():

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

const readableStream = fs.createReadStream('file.txt');
const gzipStream = zlib.createGzip();
const writableStream = fs.createWriteStream('compressed.txt');

stream.pipeline(readableStream, gzipStream, writableStream, (err) => {
  if (err) throw err;

  console.log('File compressed');
});

23. Use DuplexPair:

const Duplex = require('stream').Duplex;

const { first, second } = DuplexPair();

first.write('Hello, ');
second.on('data', (data) => {
  console.log(data.toString()); // 'Hello, world!'
});

second.write('world!');

24. Create a TransformStream with Duplex and Writable:

const { Transform, Duplex } = require('stream');

class MyTransformStream extends Duplex {
  _write(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }

  _read() { /* ... */ }
}

const transformStream = new MyTransformStream();
transformStream.on('data', (data) => {
  console.log(data.toString()); // 'HELLO, WORLD!'
});

25. Create a ReadableStream with a TransformStream and WritableStream:

const { Transform, Readable, Writable } = require('stream');

class MyReadableStream extends Readable {
  _read() {
    this.push('Hello, world!');
    this.push(null); // End the stream
  }
}

class MyWritableStream extends Writable {
  _write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
}

const readableStream = new MyReadableStream();
const writableStream = new MyWritableStream();
readableStream.pipe(writableStream);

26. Use DuplexPair for Concurrent Streams:

const { DuplexPair } = require('stream');

const { first, second } = DuplexPair();

first.write('Hello, ');
second.on('data', (data) => {
  console.log(data.toString()); // 'Hello, world!'
});

first.end('world!');

27. Use DuplexPair for Message Passing:

const { DuplexPair } = require('stream');

const { first, second } = DuplexPair();

first.write('Hello, ');
second.write('world!');

first.on('data', (data) => {
  console.log(data.toString()); // 'Hello, world!'
});

28. Use Transform to Encrypt Data:

const { Transform } = require('stream');
const crypto = require('crypto');

class EncryptTransformStream extends Transform {
  constructor(algorithm, password) {
    super();
    this.algorithm = algorithm;
    this.password = password;
    this.cipher = crypto.createCipher(algorithm, password);
  }

  _transform(chunk, encoding, callback) {
    this.push(this.cipher.update(chunk, encoding));
    callback();
  }

  _flush(callback) {
    this.push(this.cipher.final());
    callback();
  }
}

const encryptStream = new EncryptTransformStream('aes-256-cbc', 'myPassword');
encryptStream.on('data', (data) => {
  console.log(data.toString('hex'));
});

29. Use Transform to Decrypt Data:

const { Transform } = require('stream');
const crypto = require('crypto');

class DecryptTransformStream extends Transform {
  constructor(algorithm, password) {
    super();
    this.algorithm = algorithm;
    this.password = password;
    this.decipher = crypto.createDecipher(algorithm, password);
  }

  _transform(chunk, encoding, callback) {
    this.push(this.decipher.update(chunk, encoding));
    callback();
  }

  _flush(callback) {
    this.push(this.decipher.final());
    callback();
  }
}

const decryptStream = new DecryptTransformStream('aes-256-cbc', 'myPassword');
decryptStream.on('data', (data) => {
  console.log(data.toString('utf8'));
});

30. Use Transform to Compress Data:

const { Transform } = require('stream');
const zlib = require('zlib');

class CompressTransformStream extends Transform {
  constructor(algorithm) {
    super();
    this.algorithm = algorithm;
    this.compressor = zlib.createGzip();
  }

  _transform(chunk, encoding, callback) {
    this.push(this.compressor.update(chunk, encoding));
    callback();
  }

  _flush(callback) {
    this.push(this.compressor.final());
    callback();
  }
}

const compressStream = new CompressTransformStream('gzip');
compressStream.on('data', (data) => {
  console.log(data.toString('base64'));
});

31. Use Transform to Decompress Data:

const { Transform } = require('stream');
const zlib = require('zlib');

class DecompressTransformStream extends Transform {
  constructor(algorithm) {
    super();
    this.algorithm = algorithm;
    this.decompressor = zlib.createGunzip();
  }

  _transform(chunk, encoding, callback) {
    this.push(this.decompressor.update(chunk, encoding));
    callback();
  }

  _flush(callback) {
    this.push(this.decompressor.final());
    callback();
  }
}

const decompressStream = new DecompressTransformStream('gzip');
decompressStream.on('data', (data) => {
  console.log(data.toString('utf8'));
});

32. Use Transform to Convert Data to JSON:

const { Transform } = require('stream');

class JSONTransformStream extends Transform {
  _transform(chunk, encoding, callback) {
    this.push(JSON.stringify(chunk) + '\n');
    callback();
  }
}

const jsonStream = new JSONTransformStream();
jsonStream.on('data', (data) => {
  console.log(data.toString());
});

33. Use Transform to Parse JSON Data:

const { Transform } = require('stream');

class ParseJSONTransformStream extends Transform {
  _transform(chunk, encoding, callback) {
    this.push(JSON.parse(chunk));
    callback();
  }
}

const parseJSONStream = new ParseJSONTransformStream();
parseJSONStream.on('data', (data) => {
  console.log(data);
});

34. Use Transform to Filter Data:

const { Transform } = require('stream');

class FilterTransformStream extends Transform {
  constructor(predicate) {
    super();
    this.predicate = predicate;
  }

  _transform(chunk, encoding, callback) {
    if (this.predicate(chunk)) {
      this.push(chunk);
    }
    callback();
  }
}

const filterStream = new FilterTransformStream((chunk) => {
  return chunk > 5;
});

filterStream.on('data', (data) => {
  console.log(data);
});

35. Use Transform to Sort Data:

const { Transform } = require('stream');

class SortTransformStream extends Transform {
  constructor(compareFn) {
    super();
    this.compareFn = compareFn;
    this.data = [];
  }

  _transform(chunk, encoding, callback) {
    this.data.push(chunk);
    callback();
  }

  _flush(callback) {
    this.data.sort(this.compareFn);
    this.data.forEach((chunk) => {
      this.push(chunk);
    });
    callback();
  }
}

const sortStream = new SortTransformStream((a, b) => {
  return a - b;
});

sortStream.on('data', (data) => {
  console.log(data);
});

36. Use stream.pipeline() with Promises:

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

async function compressFile(input, output) {
  return new Promise((resolve, reject) => {
    stream.pipeline(
      fs.createReadStream(input),
      zlib.createGzip(),
      fs.createWriteStream(output),
      (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      }
    );
  });
}