Node js

Advantages of Node.js are mentioned as below:- 

1. Easy Scalability:- Applications which are developed on Node.js are easy to scale in horizontal and vertical directions. 
2. Easy to Learn:- Node.js is very easy to learn and implement. It can be easily used in Frontend and backend. This is the only reason why this is so popular among developers. 
3. Fullstack Language:- Node.js is a fullstack language which means it can be used at Server side and client side applications. A single developer can handle both frontend and backend application which results in saving time and money. 
4. High Performance:- An application developed on Node.js performs very well in the runtime as it directly compiles the code into Machine code which helps in easy maintaining and  implementing of the code.  
5. Open Source Runtime Environment:- Node.js also provides a functionality to caching data into a single module, which helps in storing the data in application memory. So at runtime there should not be any buffering issue and it is much faster as compared to other languages.  

Disadvantages of Node.js are mentioned as below:- 

1. Library Support System:- Node.js language does not have its own library support system so developers have to depend upon external sources. For example, if you want to process any image, in cases such as fetching data from database or data parsing,  developers have to take help from a common library.  
2. Asynchronous Programming Model:- Node.js programming supports asynchronous programming model which is advised if you want to make a scalable or flexible application. But the majority of developers observed that this model was more difficult as compared to linear programming. It is a very tedious task to find out an error or fault functions in this type of programming model.  
3. Unstable Application Programming Interface:- It has been observed that API is not the same in the application developed in Node.js, so many developers face difficulties or are bound to make changes in their code to match with the latest available API of Node.js. 

The following tools are very popular:- 

1. ESLint:- This is also an open source linting utility which helps developer to overcome very common errors and also provides flexibility to developers for creating their own linting rules.   
2. JSCS:- This is also a code style linter tool which was merged with ESLint in April 2016. 
3. JSLint :- JSLint is a code quality tool that takes a JavaScript source and scans it. On the off chance that it finds an issue, it restores a message portraying the issue and a surmised area inside the source. The issue isn't always a syntax error, despite the fact that it frequently is.JSLint sees some style conventions just as auxiliary issues. 
4. JSHint:- this is a Static Code Analysis Tool for JavaScript. JSHint is a network driven instrument that identifies mistakes and potential issues in JavaScript code. Since JSHint is so adaptable, you can, without much of a stretch, alter it in the nature you anticipate that your code should execute. JSHint is open source and will consistently remain along these lines. 

Node.js is an open source server-side JavaScript run-time condition based on Chrome's JavaScript Engine(V8). Node.js is utilized to structure quick and adaptable applications and is an occasion driven, non-blocking I/O model.  

REPL (READ, EVAL, PRINT, LOOP) is a PC situation like Shell (Unix/Linux) and direction brief. A command is entered and the system responds with an output. The hub accompanies the REPL condition when it is introduced, and the Framework associates with the client through yields of directions/articulations utilized. 

Node.js or Node comes bundled with a REPL environment that performs the following desired tasks. 

• Read : It peruses the contributions from clients and parses it into JavaScript information structure. It is then put away to memory.  
• Eval : The parsed JavaScript information structure is assessed for the outcomes.  
• Print : The outcome is printed after the assessment.  
• Loop : Loops the information order. To leave NODE REPL, press ctrl+c twice 

We have repl module which is available for standalone applicationsas well,  and can be called through below command:- 

const repl = require('repl'); 

Underscore variable is a special kind of variable which usually stores the value of its last execution result. Whenever you need to use the output of one module to the input of next module you may use this variable. It serves asimilar purpose as $? in bash. Please find below an example for a more detailed explanation:-  

Use _ to get the last result. 

C:Nodejs_WorkSpace>node 

> var x = 10 
undefined 
> var y = 20 
undefined 
> x + y 
30 
> var sum = _ 
undefined 
> console.log(sum) 
30 
undefined 
> 

In Version 6.x or higher Underscore variable gives you the following result:- 

> [ 'a', 'b', 'c' ]  
[ 'a', 'b', 'c' ]  
> _.length 3  
> _ += 1  

Expression assignment to _ now disabled.  

4  
> 1 + 1  
2  
> _  
4 

In older version you will get a different result:- 

> [ 'a', 'b', 'c' ] 
[ 'a', 'b', 'c' ] 
> _.length 
3 
> _ += 1 
4 
> 1 + 1 
2 
> _ 
2 

• GLOBAL Dependencies:- We have to keep all global packages or dependencies into <user-directory>/npm directory. All global dependencies can only be used in the Command Line Interface function into any node.js but it cannot be directly imported using require () into any application. For installing any global package into Node project globally use -g flag. Please use the following command for installing any Global dependency. 
• Command :- C:Nodejs_WorkSpace>npm install express -g 
• LOCAL Dependencies:- Any local package gets installed in the local mode only,ie into Local_modules directory present in the folder where the node js application is installed or kept. Local dependencies can only be accessed by require() function. For installing the node project into local directory, or installing any local dependency, we have to use the following command:- 
• Command:- C:Nodejs_WorkSpace>npm install express 
• We can use following command for fulfilling the above purpose:- C:Nodejs_WorkSpace>npm ls -g 

Applications made using Node.js create a single thread, which means it receives a request and processes it first before moving to another request. So if you are developing any streaming application or event based application, then Node.js is best suited for it. Some examples of such applications are as follows:- 

• Chat Applications:- In chat applications,where there are multiple users logged in and chatting with multiple agents, a fast and high performance server is needed to handle such multiple requests simultaneously. 
• Gaming Applications:- Gaming applications are the best example of collaboration work where multiple teams are working on different modules and at the same time. To support such applications it is very necessary to keep a good control on version management system. Node.js has a very powerful Event Loop feature which supports the above scenario. It can handle multiple events at the same time, without blocking other components of the application.  
• Advertisement Applications/Servers:-  Node.js is the best solution for accepting multiple requests for downloading the ads from the server, and its response time is very less.   
• Streaming Applications:- In any applications which interact with online streaming server, users send multiple requests to servers for different queries. In this case we have to use Node.js because of its high accuracy and less CPU usage. 

The package.json file is the core of Node.js system. It is the main file of any Node.js project and contains the complete information about the project. Developers have to have a deep understanding of package.json file to work with Node.js. It is the first step to learn about development in Node.js. Package.jason is mostly used for defining the properties of a package and it is always present in the root directory folder of any Node js application. The most common attributes of Package.Jason are as following:- 

• name - Name of the package 
• version - Version of the package 
• description - Brief description of the package 
• homepage - Homepage of the package 
• author - Author of the package 
• contributors - Name of the contributors to the package 
• dependencies - List out all dependencies and npm will automatically install all the dependencies described here.  
• repository - Repository type and url of the package 
• main - Starting point of the package 
• keywords - Important keywords 

Node Package Manager (NPM) provides two primary functionalities − 

• Online vaults for node.js bundles/modules which are accessible on search.nodejs.org. 
• Command line utility for interacting with the requested/required repository which is included in the package installation, and to do version management and dependency management of Node.js bundles. 

www.npmjs.com hosts thousands of free packages to download and use. The NPM program is installed on your computer when you install Node.js. There might be a scenario when we are required to either uninstall a dependency or have to update an existing dependency, so please use the following command for uninstalling any dependencies through NPM: 

C:Nodejs_WorkSpace>npm uninstall <Name of dependency here> 

Please use the following command for updating any dependencies through NPM 

C:Nodejs_WorkSpace>npm update <Name of dependency here> 

To get the old behavior, use npm --depth 9999 update . As of npm@5.0.0 , the npm update will change package.json to save the new version as the minimum required dependency. To get the old behavior, use npm update --no-save 

In general programming terms, event-driven programming is a programming technique in which the flow of the program is determined by events such as user actions (mouse clicks, key presses), sensor outputs, or messages from other programs or threads.

As we know, Node.js is a single threaded application but it can support multithreading through Event and callback function. Event Driven programming is running on Request and response technique. We have to define a target which may be any button or click event so whenever our application is going to receive a request on the target our application will accept and process that request, and provide a response back to the user. This is usually achieved through Callback function. You can review the below example for more reference:-

function addtoStudent(studentId) 
{ 
event.send("student.add" , {id: studentId}) 
} 
event.on("student.add", function(event) 
{  
show("Adding New Student" +event.id); 
});

• Convert Buffer to JSON
• Reading from Buffers
• Concatenating Buffers
• Compare Buffers
• Copy Buffer

Example:

How to convert binary equivalent of stream xyz to JSON format:

create a javascript file with following code.

var buf = Buffer.from('xyz');
console.log(buf.toJSON());

in the first line buf is the variable and Buffer is the Buffer class. Using toJSON method we can convert code as shown in the result below.

Execute the code : Following is the result

{ type: 'Buffer', data: [ 120, 121, 122 ] }

Duplex: Duplex streams are streams that implement both readable and writable interfaces

Examples:

1. TCP sockets
2. zlib streams ( Compression library functionality streams)
3. cypto streams ( Cryptography functionality streams)

Transform: A type of duplex streams where output is in someway related to the input. Like duplex streams, Transform streams also implement both Readable and Writable interfaces.

Examples: 

1. zlib streams ( Compression library functionality streams)
2. cypto streams ( Cryptography functionality streams)

Piping is 

• a mechanism where output of one stream is provided as input to another stream 
• normally used to get data from one stream and pass the data to another stream

No limit on piping operations.

Example: Create a text file dataSinput.txt with the following content.

• Monday is first day of week
• Tuesday is second day of week
• Wednesday is third day of week

After executing the following code you can view the contents in the outputfile.

var fs = require("fs"); //import fs module
//creating a readstream to read our inputdatafile dataSinput.txt
var readStream = fs.createReadStream("F://dataSinput.txt");
//creating a writestream(initially empty) which is destination for transferred data 
var writeStream = fs.createWriteStream("F://dataSoutput.txt");
//Use Pipe command to transfer from readstream to writestream. 
//Pipe command takes all data from readstream and pushes it to writestream 
readStream.pipe(writeStream);

Output in dataSoutput.txt can be seen as

• Monday is first day of week
• Tuesday is second day of week
• Wednesday is third day of week

Chaining is

• a mechanism to connect output of one stream to another stream and create a chain of multiple stream operations.
• normally used with piping operations.

Example: Create a text file dataSinput.txt with the following content.

• Monday is first day of week
• Tuesday is second day of week
• Wednesday is third day of week

After executing following code.

var fs = require("fs"); //import fs module
var zlib = require("zlib"); //import zlib module
//creating a readstream to read our inputdatafile dataSinput.txt
var readStream = fs.createReadStream("F://dataSinput.txt");
//create a compressed folder zlib
var czlib = zlib.createGzip();
//creating a writestream(initially empty) which is destination for transferred data 
var writeStream = fs.createWriteStream("F://dataSoutput.txt.gz");
//Use Pipe command to transfer from readstream to gzip. 
//Pipe commands takes all data from readstream and pushes it to compressed writestream file  
readStream.pipe(czlib).pipe(writeStream);
console.log("File Compressed");

You get result as “File Compressed”. And compressed file dataSoutput.txt.gz as output Which consists of text file dataSoutput.txt.

Yes.Every method of fs module supports both synchronous and asynchronous forms.

Asynchronous methods take the first parameter of callback function as error and last parameter as completion function.

It is better to use an asynchronous method as it never blocks as program during execution whereas synchronous methods does block the program during execution.

A common question in Node js advanced interview questions, don't miss this one.  

import fs module and declare buffer class

1. Open the file using fs.open method
2. Execute the method ftruncate to truncate the opened file. Provide the name of the opened file , length of file after which the file will be truncated.
3. Read the truncated file after successful truncation using fs.read method and buffer
4. iclose the file using fs.close method

Example: Create a text file named trnk.txt with Knowledgehut tutorials as text in it

Create a javascript code as follows. Save it as trnkexmpl.js

var fs = require("fs"); //import module
var buf = new Buffer(1024); //define buffer
 
fs.open('trnk.txt', 'r+', function (err,fd) {
if (err) {
return console.error(err);
}
console.log("File opened");
//Truncate the open file)
fs.ftruncate(fd, 12, function(err) {
if (err) {
return console.log(err);
}
console.log("File Truncated")
console.log("Going to read same file") 
fs.read(fd, buf, 0, buf.length, 0 ,function(err, bytes) {
if(err) {
return console.log(err); 
}
//Print only read bytes
if(bytes > 0) {
console.log(buf.slice(0, bytes).toString());
}
 
//Close the opened file
fs.close(fd, function(err){
if (err) {
console.log(err);
}
console.log("File closed successfully");
});
});
});
 
});
 

Execute the code . You get the following result:

• File opened
• File Truncated
• Going to read same file
• Knowledgehut
• File closed successfully

1. import fs module
2. delete the file using fs.unlink method and name of file to be deleted as parameter.

Create a text file “demo_file_del.txt” file to be deleted.

var fs = require("fs");  //import fs module
console.log("going to delete demo_file_del.txt file")
fs.unlink('demo_file_del.txt', function(err) { // call unlink method)
if (err) {
return console.err(err);
}
console.log("File deleted successfully")
});

Result: 

• going to delete demo_file_del.txt file
• File deleted successfully
• demo_file_del.txt was deleted.

The “error-first” callback  is also known as an “errorback”, “errback”, or “node-style callback”. Error-first callbacks are utilized to pass errors and data too. You need to pass the error as the main parameter, and you must verify whether something went wrong. Additional arguments are utilized to pass data.  There are two rules for defining an error-first callback: 

1. The first argument of the callback is reserved for an error object.If an error occurred, it will be returned by the first err argument. 
2. The second argument of the callback is reserved for any successful response data. If no error occurred, err will be set to null and any successful data will be returned in the second argument. 

Code example is as below:- 

fs.readFile(filePath, function(err, data) {   
  if (err) { 
    // handle the error, the return is important here 
    // so execution stops here 
    return console.log(err) 
  } 
  // use the data object 
  console.log(data) 
}) 

Callback Hell no more with Promises and its nearby partner, Generators. ... It comprises of numerous settled callbacks which makes code hard to pursue and investigate. One may unconsciously get captured in Callback Hell while managing asynchronous logic. Callback hell is a marvel that torments a JavaScript designer when he attempts to execute different nonconcurrent tasks in a steady progression. You may use any of the below options for resolving the issue of callback hells: 

1. Use async/await :- This option is very famous among developers because it will help you to write down your code in a synchronous manner although it is still asynchronous  
2. Use a control flow library 
3. Modularization: break callbacks into independent functions 
4. Use generators with Promises :- This will make application code shorter and easier to understand. This will also help another programmer to enhance the old codebase as per new requirements.  

Promises are a simultaneousness primitive, first depicted during the 80s. Presently they are a part of most current programming languages to make your life simpler. Promises can enable you to handle async activities.  

Please see the below example, which will help you understand the code simplicity and scalability using or without using Promise. 

Code example without using Promise:- 

var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost/EmployeeDB';
MongoClient.connect(url, function(err, db) 
{ 
db.collection('Employee').insertOne({
Employeeid: 4,
EmployeeName: "NewEmployee"
    });
}); 

The portion of the function(err, db) in the above code is known as an anonymous or callback function declaration. When the MongoClient connects to the MongoDB database, it returns to the callback function once the connection is complete. In a way, the link operations occur in the background, and it calls our callback function when it is completed. Note that this is one of Node.js' key points to allow multiple operations to occur simultaneously, thereby preventing any user from carrying out an operation. 

So then what's a promise? Ok, a promise in Node.js is just an update to callback functions. There may be an instance during the software lifecycle where several callback functions need to be nestled together. At some point in time, this can getmessy and difficult to maintain. In short, a promise is a callback improvement that aims to mitigate these issues. 

The basic syntax of a promise is shown below; 

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected) 

Code example using Promise:- 

var Promise = require('promise');
var MongoClient = require('mongodb').MongoClient; 
var url = 'mongodb://localhost/EmployeeDB'; 
MongoClient.connect(url)
    .then(function(err, db) {
db.collection('Employee').updateOne({
            "EmployeeName": "Martin"
        }, {
            $set: {
                "EmployeeName": "Mohan"
            }
        });
    }); 

• The first part is to include the 'promise' module which will allow us to use the promise functionality in our code. 
• We can now append the 'then' function to our MongoClient.connect function. So what this does is that when the connection is established to the database, we need to execute the code snippet defined thereafter. 
• Finally, we define our code snippet which does the work of updating EmployeeName of the employee with the name of "Martin" to "Mohan". 

We can easily load HTML code into Node.Jsby making a change in the content type. In HTML Code content type is defined as “text/plain” and for loading this into Node.Js we have to change it to “text/html”. Please see below example for more detail:-

fs.readFile(filename, "binary", function(err, file) { 
if(err) {  
response.writeHead(500, {"Content-Type": "text/plain"}); 
response.write(err + "\n"); 
response.end(); 
return; 
} 
response.writeHead(200); 
response.write(file, "binary"); 
response.end(); 
}); 

Now we have to modify the above code to load an HTML page instead of plain text like as below:-

fs.readFile(filename, "binary", function(err, file) { 
if(err) {  
response.writeHead(500, {"Content-Type": "text/html"}); 
response.write(err + "\n"); 
response.end(); 
return; 
} 
response.writeHead(200, {"Content-Type": "text/html"}); 
response.write(file); 
response.end(); 
}); 

A mechanism which is designed to handle async callbacks is known as Event loop. Node.js is a single threaded and event driven programming language. We can attach any listener on the request node and whenever it is triggered with a known request then listener will accept and process it based on the predefined callback functions which we have setup in our application.    

At whatever point we are callingsetTimeout, http.get and fs.readFile, Node.js runs these tasks and further keeps on running other programs without waiting for the output. At the point when the activity is done, it gets the output and runs our callback function.  

So all the callback functions are lined in a circle, and will run individually whenever we receive the response. 

The module.exports or exports is an uncommon article which is incorporated into each JS record in the Node.js application as a matter of course. The module is a variable that speaks to current module and exports is an item that will be uncovered as a module. Thus, whatever you allocate to module.exports or send out, will be uncovered as a module. Each Module in Node.js has its own functionality and that cannot interfere with the other modules.   

A module encapsulates related code into a solitary unit of code. This can be translated as moving every single related function into a document. Envision that we made a document called greetings.js and it contains the following two functions: 

module.exports = { printAdditionInMaths: functions() 
{ return "+"; }, 
printSubtractionInMaths: functions() 
{ return "-";} }; 

In the above example, module.export has exposed 2 functions which can be called out in any other program as shown below:- 

Var mathematics = require(“./mathematics.js) 

mathematics.printAdditionInMaths();
mathematics.printSubtractionInMaths();

Asynchronous truly implies not synchronous. If we are making HTTP requests which are asynchronous, it implies we are not waiting for the server reaction. 

The term Non-Blocking is broadly utilized with IO. For instance non-blocking read/compose calls come back with whatever they can do and anticipate that the user should execute the call once more. Peruse will hold up until it has some information, and put calling thread to rest. 

An asynchronous consider demands an exchange that will be performed in its whole(entirety) yet will finish at some future time. Non-blocking: This capacity won't pause while on the stack. Synchronous is characterized as occurring simultaneously. Asynchronous is characterized as not occurring simultaneously. 

Please review the below example to understand better:- 

Synchronous & blocking 

1. phone.waitForCall(); // Current thread is blocked 
2. phone.getCall().answer(); 
3. book.read(); 

Synchronous & non-blocking 

1. while (!phone.hasCall()) { 
2. book.readWithTimeout(someTime); 
3. } 
4. phone.getCall().answer();   // PhoneCall::answer is called here 
5. book.read(); 

Asynchronous 

1. // We can't tell the context where the callback is called. 
2. // But it is definitely not the current context. 
3. phone.onRing(PhoneCall::answer); 
4. book.read(); 

A reusable block of code which may not impact the other codes through its presence is called a Module. Modules are presented in ES6. Modules are significant for Maintainability, Reusability, and Namespacing of Code. 

Module in Node.js is a basic or complex functionality organized  in single or various JavaScript documents which can be reused all through the Node.js applications.  

Every module in Node.js has its own unique circumstances, so it can't meddle with different modules or contaminate global modules. Additionally, every module can be put in a different .js record under a different envelope.  

Node.js actualizes CommonJS modules standard. CommonJS is a gathering of volunteers who characterize JavaScript guidelines for web server, work area, and reassure application. 

Node.js includes three types of modules: 

1. Core Modules:- Node.js is a lightweight framework and core modules carry the minimal functionality of Node.js. 
2. Local Modules:- Any Module which is locally created for one application and doesn’t have any scope outside the parent application is known as a Local Module.  
3. Third Party Modules:- All external functionality which is available through export module can be imported and used in the application is called a Third Party Module. 

libuv is a fabulous asynchronous IO library. It has a high productive event loop, and additionally has a separate answer for io blocking activity. It has an interior laborer thread pool for io blocking operation(E.g. submit io blocking work through uv_queue_work). So it accomplishes incredible execution by consolidating both asynchronous event loops and thread pools for non-io blocking and io blocking activity. It is a decent decision for superior server.   

If the synchronous thread pool model is what you are used to on an everyday basis, you may find the asynchronous model somewhat hard, particularly when you have to decide when is the best time to discharge the "handles". If you do not get that right, libuv will crash and make your troubleshooting difficult. 

libuv is a Cross-platform I/O abstraction library that supports asynchronous I/O based on event loops.It is written in C and released under the MIT Licence. 

libuv support Windows IOCP, epoll(4), kqueue(2), and Solaris event ports. Initially, it was designed for Node.js but later it is also used by other software projects. 

Reference : https://en.wikipedia.org/wiki/Libuv 

It's no surprise that this one pops up often in Node js interview questions for experienced.  

The Zlib module provides a way to zip and unzip files. Zlib is a Cross-stage data compression library. It was composed by Jean-loupGailly and Mark Adler. In Node js, you can Zlib for Threadpool, HTTP solicitations, and reactions pressure and Memory Usage Tuning. So as to utilize zlib in node js, you have to introduce hub zlib bundle. After establishment, below is the test code to utilize Zlib. 

var Buffer = require('buffer').Buffer; 
var zlib = require('zlib'); 
var input = new Buffer('lorem ipsum dolor sit amet'); 
var compressed = zlib.deflate(input); 
var output = zlib.inflate(compressed); 

Following are a few important Zlib properties and Methods:- 

MethodDescription 

• constantsReturns an object containing Zlib constants 
• createDeflate()Creates a Deflate object 
• createDeflateRaw()Creates a DeflateRaw object 
• createGunzip()Creates a Gunzip object 
• createGzip()Creates a Gzip object 
• unzip()Decompress a string or buffer using Unzip 
• unzipSync()Decompress a string or buffer, synchronously using Unzip 
• deflate()Compress a string or buffer using Deflate 
• gzip()Compress a string or buffer using Gzip 
• gzipSync()Compress a string or buffer, synchronously using Gzip 
• inflate()Decompress a string or buffer using Inflate 
• inflateSync()Decompress a string or buffer, synchronously using Inflate 

Node.js file system module is capable of working on files either on your local system or database, but working on file system we have to call require() method for calling a file server. Through Node.js we can even open any http file and perform read content operation. 

NodeJs peruses the content of a document in a non-blocking, nonconcurrent way. Node JS utilizes its fs center API to manage documents. The simplest method to peruse the whole substance of a document in nodeJs is with fs.readFile strategy. The following is a test code to peruse a record in NodeJs asynchronously and synchronously. 

Reading a file in node asynchronous/ non-blocking 

var fs = require('fs');  
fs.readFile('DATA', 'utf8', function(err, contents) { 
    console.log(contents); 
}); 
console.log('after calling readFile'); 
Reading a file in node asynchronous/blocking 
var fs = require('fs');  
var contents = fs.readFileSync('DATA', 'utf8'); 
console.log(contents); 

One of the most frequently posed Node js interview questions for experienced, be ready for it.  

Streams are accumulations of information — simply like clusters or strings. What matters is that streams probably won't be accessible at the same time, and they don't need to fit in memory. This makes streams extremely amazing when working with a lot of information, or information that is originating from an outer source one piece at once.  

Notwithstanding, streams are not just about working with enormous information. They additionally give us the intensity of composability in our code. Much the same as we can create ground-breaking Linux directions by funneling other littler Linux directions, we can do the equivalent in Node with streams precisely. 

Streams are extraordinary kinds of objects in Node that enable us to peruse data from a source or compose data for a goal consistently. There are 4 kinds of streams accessible in Node Js; they are:

• Comprehensible − For perusing task.  
• Writable − For composing task.  
• Duplex − Used for both read and composing tasks.  
• Change − A kind of duplex stream where the yield is figured dependent on the information. 

Node.js is a runtime framework that has turned out to be famous with most coders and is utilized generally for creating server-side applications. Node.js is best known for making constant APIs and building another network of interoperability over the web. There are two manners by which a record can be perused and sent for execution in Node.js; readFile and CreateStream. Please see a few major differences in readfile and createStream as below:- 

1. readFile load the entire record which you had set apart to peruse though createReadStream peruses all records in the parts of the size you have proclaimed.  
2. The customer will get the information quicker on account of createReadStream interestingly with readFile.  
3. In readFile, a record will first totally peruse by memory and after that moves to a customer yet in later choice, a document will be perused by memory in a section which is sent to customers and the procedure proceeds until every one of the parts is wrapped up. 

Node.js file system module is capable to work on file either on your local system or database but working on file system we have to call require() method for calling a file server. This can be understood by the following example:- 

Var fs = require(‘fs’); 

Basic activities or operations which are required for working on file are as mentioned below:- 

• Read a file :- We have to call/use fs.readFile() method for reading any file on our local system or any http file. For example:- 

var http = require('http'); 
var fs = require('fs'); 
http.createServer(function (req, res) { 
  fs.readFile('demofile1.html', function(err, data) { 
    res.writeHead(200, {'Content-Type': 'text/html'}); 
res.write(data); 
    res.end(); 
  }); 
}).listen(8080);   

• Create a file:- For creating any new file we have three different methods which are as follows:-  fs.appendFile(); 

    fs.open(); 
    fs.writeFile(); 

• Update a file:- For creating any new file we have two different methods which are as follows:- fs.appendFile(); 

   fs.writeFile(); 

• Delete a file:- For deleting any file with file system module we have to use the following method:- fs.unlink() 
• Rename a file:- For renaming any file with file system module we have to use the following method:- fs.rename() 

A set of code which always operates in between multiple asynchronous function call is called Control Flow. You may describe it as a function because it takes some input and provides you or its next functions an output. Control Flow usually controls the function by using the following steps:-

• Control the order of execution
• Collect data
• Limit concurrency
• Call the next step in program

We have three different patterns which can explain more about control functions :-

1. Control flow pattern #1: Series - an asynchronous for loop:- Consider a case when you have multiple programs and the first program provides a feed to the second program, and third to fourth in a sequential manner. So in this case we just need to trigger one async () operation and pass callback to it. This will trigger all remaining programs and provide you the expected results.
2. Control flow pattern #2: Full parallel - an asynchronous, parallel for loop :- Consider a case when our application requires feed from different other systems which may or may not require to run in a sequence. Whenever all prerequisite programs are finished and provide a feed to our application then only our process will trigger. So this scenario we just have to worry about the available resources so that prerequisite applications should not consume all resources and later applications will always be on HOLD stage.
3. Control flow pattern #3: Limited parallel - an asynchronous, parallel, concurrency limited for loop:- In this flow a fresh async () function will call till the time application consumes all the available resources and every operation will store the results of its operation. After successful completion of first async operation launcher() will call it again unless there is no application pending to run. Once our application achieves this stage then we will call final() for processing the final information and share the output/result with the user.