Put some lines of text in here.

const fs = require('fs');

fs.readFile('smallfile.txt', 'utf8', function(err, data) {
  if (err) return console.error(err.message);
  console.log(data);
});

const readStream = fs.createReadStream('./hugeFile.txt', 'utf8');

• The format to create a read stream object is: fs.createReadStream(path[, options]) 

• Set the encoding option to 'utf8' for text, otherwise it returns a buffer object. 
• When this method is called, Node starts reading the file.

---

Data Stream Explanation

• The Stream module inherits from the Buffer and Events modules.
• The file data is loaded as a stream of bytes which are temporarily accumulated in a buffer object in RAM memory. 
• Node's core Buffer module manages this part behind the scenes. 
• The buffer stores the bytes in an array. When the buffer's array reaches its maximum size it passes the data as a chunk to be processed for output (e.g., played as a video). 
• The default buffer size is 64 KB. One byte holds one text character so the buffer is every 64k characters.
• The stream module inherits from the EventEmitter class. 
• When a chunk of data is sent from the buffer, a data event is emitted behind the scenes.
• A listener function needs to be in place to handle the data chunk on the data event.
• For large files, streaming has two advantages. 
• It uses less memory than if you loaded the whole file at once.
• If it is a video file, the user can start watching the video before it is fully loaded. 

---

ReadStream Events

let count = 0;

• Start the count variable at 0. We will be adding 1 to count every time a new chunk is created.

readStream.once('data', () => {
  console.log('Start the data stream');
});

• When a data chunk is sent it emits a data event. Use the once method to listen for the data event the first time it occurs, then handle it with a callback function.
• The format is:

readStream.on('end', () => {
  console.log('Data stream complete. Chunk count: ', count);
});

readStream.on('error', (err) => {
  console.error(err.message);
});

• Make sure to also listen for the error event to handle errors. The format is:

Create a Write Stream

nodejs-tutorial/6-stream/readWriteStream.js

const fs = require('fs');

const readStream = fs.createReadStream('hugeFile.txt', 'utf8');
const writeStream = fs.createWriteStream('output.txt');

let count = 0;
readStream.on('data', (chunk) => {
  console.log(`Chunk ${++count} received: ${chunk.length} characters`);
  writeStream.write(chunk);
});

• Start by creating a readStream object, passing in hugefile.txt, encoded as utf8 text. As a reminder, the format to create a readStream object is:

• And create a writeStream object with the output file named output.txt as the argument. The format for a writeStream object is: 

• In the readStream: 
• The on method is listening for the data event. The data event occurs every time a chunk of data is created.
• In the callback function the first argument is the chuck of data received. 
• We are incrementing the chunk count variable by 1 then logging it. Along with the chunk length property which is the number of bytes. In a text file a byte holds one character.
• Then we call the write method on our writeStream object, passing in the chuck of data.

The Pipe method

nodejs-tutorial/6-stream/pipeStream.js

const fs = require('fs');

const readStream = fs.createReadStream('hugeFile.txt', 'utf8');
const writeStream = fs.createWriteStream('output2.txt');

readStream.pipe(writeStream);

• Like before we set variables for the readstream and writestream objects.
• The shortcut is, instead of chaining the on method to the readstream, listening for the data event, then handling each chunk by writing it to the writestream;
• we simply chain the pipe method to the readStream object and pass in the writeStream as the argument.
• This has the same result as the last file we executed except we aren't logging the chunk count this time. The output file this time is output2.txt.

Create a video streaming web application

Initiate a package.json file

package.json

{
  ...
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  ...
}

index.html file

index.html

<html>
  <head>
    <title>Node stream video example</title>
  </head>
  <body>
    <h1>How To Build a Video App</h1>
    <!-- controls attribute shows the video controls at the bottom of the video screen -->
    <video width="1080" controls> 
      <source src="/video" type="video/mp4">
    </video>
  </body>
</html>

index.js

index.js

const express = require('express');
const fs = require('fs');
const path = require('path');
const app = express();

// 1. Respond to request to / root path with the index.html document 
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, '/index.html'));
});

// 2. Respond to request to /video path.
app.get('/video', (req, res) => {
  const videoPath = './stream-tutorial.mp4';
  // 3. Get video size (in bytes)
  const videoSize = fs.statSync(videoPath).size;

  // 4. Set chunk size to 1MB (default is 64KB)
  const chunkSize = 1000000;
  // 5. Get the video range string from the request headers
  const range = req.headers.range;
  // 6. Starting point: remove non-digits from the range string and convert it to a number.
  const start = Number(range.replace(/\D/g, ''));
  const end = Math.min(start + chunkSize, videoSize - 1);
  // 7. Get the chunk size being sent. 
  const contentLength = end - start + 1;

  // 8. Create the response headers.
  const headers = {
    'Content-Range': `bytes ${start}-${end}/${videoSize}`,
    'Accept-Ranges': 'bytes',
    'Content-Length': contentLength,
    'Content-Type': 'video/mp4'
  }
  // 9. Add headers to response object. HTTP Status 206 is for partial content
  res.writeHead(206, headers);

  // 10. Create read stream for the current chunk of video.
  const readStream = fs.createReadStream(videoPath, { start, end });
  // 11. Pipe the video chunk to the response object to send to the client.
  readStream.pipe(res);
});

// 12. Listen for client requests on port 3000
app.listen(3000, () => {
  console.log('Listening on port 3000');
});