MeanStack Interview Questions and Answers

• It is a JavaScript-based platform or runtime, which is built on Chrome’s V8 JavaScript engine. It is a single-threaded program which employs the concurrency models that are based on the event loop. Instead of blocking the execution, it registers a callback which allows the applications to run. So, as per it, Node.js can handle all these concurrent operations without making multiple thread execution which can be scaled pretty well. 

• Along with JavaScript, it uses C and C++. These are used for interacting with the file system. Then, they started using servers that are based on HTTP or TCP. Because of its rapidly growing popularity, it is now the most common platform for cross-platform or open platform apps. With the help of this, you can develop fast and scalable network apps that can be run smoothly on Linux, Microsoft Windows, or OSX.

• Angular’s route guards are interfaces which can tell the router whether or not it should allow navigation to a requested route.

• They make this decision by looking for a true or false return value from a class which implements the given guard interface.

• Asynchronous event driven IO helps concurrent request handling – All APIs of Node.js are asynchronous. This feature means that if a Node receives a request for some Input/Output operation, it will execute that operation in the background and continue with the processing of other requests. Thus it will not wait for the response from the previous requests.

• Fast in Code execution – Node.js uses the V8 JavaScript Runtime engine, the one which is used by Google Chrome. Node has a wrapper over the JavaScript engine which makes the runtime engine much faster and hence processing of requests within Node.js also become faster.

• Single Threaded but Highly Scalable – Node.js uses a single thread model for event looping. The response from these events may or may not reach the server immediately. However, this does not block other operations. Thus Node.js highly scalable. Traditional servers create limited threads to handle requests while Node.js creates a single thread that provides service to much larger numbers of such requests.

• Node.js library uses JavaScript – This is another important aspect of Node.js from the developer’s point of view. The majority of developers are already well-versed in JavaScript. Hence, development in Node.js becomes easier for a developer who knows JavaScript.

• There is an Active and vibrant community for the Node.js framework – The active community always keeps the framework updated with the latest trends in the web development.

• No Buffering – Node.js applications never buffer any data. They simply output the data in chunks.

The term MEAN stack refers to a collection of JavaScript-based technologies used to develop web applications. MEAN is an acronym for MongoDB, ExpressJS, AngularJS, and Node.js. From client to server to database, MEAN is full stack JavaScript.

• we can use Node.js for a variety of applications. But it is a single threaded framework, so we should not use it for cases where the application requires long processing time.

• If the server is doing some calculation, it won’t be able to process any other requests. Hence, Node.js is best when processing needs less dedicated CPU time.

Express is one the most prevalent and generally utilized web systems in Node.js advancement zone. Express is a negligible web server based on Node.js that gives all the basic features required to handle web applications to the program and cell phones. ExpressJS enables you to deal with Routes, Server, and I/O stuff effortlessly.

Consistent Style helps team members modify projects easily without having to get used to a new style every time. Tools that can help include Standard and ESLint.

The REPL stands for “Read Eval Print Loop”. It is a simple program that accepts the commands, evaluates them, and finally prints the results. REPL provides an environment similar to that of Unix/Linux shell or a window console, in which we can enter the command and the system, in turn, responds with the output. REPL performs the following tasks.

• READ – It Reads the input from the user, parses it into JavaScript data structure and then stores it in the memory.

• EVAL-It Executes the data structure.

• PRINT – It Prints the result obtained after evaluating the command.

• LOOP – It Loops the above command until the user presses Ctrl+C two times.

• Angular services are singleton objects which get instantiated only once during the lifetime of an application. They contain methods that maintain data throughout the life of an application, i.e. data does not get refreshed and is available all the time. The main objective of a service is to organize and share business logic, models, or data and functions with different components of an Angular application.

• The separation of concerns is the main reason why Angular services came into existence. An Angular service is a stateless object and provides some very useful functions.

The most common types of IDE’s that can be used for Node.JS development applications are:

• Cloud9

• JetBrainsWebStorm

• JetBrains IntelliJ IDEA

• Komodo IDE

• Eclipse

• Atom

OneTime Setup

• npm install -g @angular/cli
• ng new projectFolder creates a new application

Bundling Step

• ng build --prod (run in command line when directory is projectFolder)
• flag prod _bundle for production

bundles are generated by default to projectFolder/dist/

Deployment

You can get a preview of your application using the ng serve --prod command that starts a local HTTP server such that the application with production files is accessible.

For a production usage, you have to deploy all the files from the dist folder in the HTTP server of your choice.

• Angular Elements – Angular Elements is a project that lets you wrap your Angular components as Web Components and embed them in a non-Angular application.

• New Rendering Engine: Ivy – increases in speed and decreases in application size.

Tree-shakeable providers – a new, recommended, way to register a provider, directly inside the @Injectable() decorator, using the new providedIn attribute.

RxJS 6 – Angular 6 now uses RxJS 6 internally, and requires you to update your application also. RxJS released a library called rxjs-compat, that allows you to bump RxJS to version 6.0.

ElementRef<T> – ElementRef had its nativeElement property typed as any. In Angular 6.0, you can now type ElementRef more strictly.

Animations – The polyfill web-animations-js is not necessary anymore for animations in Angular 6.0, except if you are using the AnimationBuilder.

i18n – possibility to have “runtime i18n”, without having to build the application once per locale.

Following is the code snippet to fetch Post Data using Node.js.

app.use(express.bodyParser());

app.post(‘/’, function(request, response){

console.log(request.body.user);

});

Following code snippet can be used to make a Post Request in Node.js.

var request = require(‘request’);

request.post(

‘http://www.example.com/action’,

{ form: { key: ‘value’ } },

function (error, response, body) {

if (!error && response.statusCode == 200) {

console.log(body)

}

}

);

Angular.JS is a web application development framework while Node.js is a runtime system

Mongoose is an Object Document Mapper (ODM). This means that Mongoose allows you to define objects with a strongly-typed schema that is mapped to a MongoDB document.

• A common trait between Node.js, AJAX, and jQuery is that all of them are the advanced implementation of JavaScript. However, they serve completely different purposes.

• Node.Js – It is a server-side platform to develop client-server applications. For example, if we’re to build an online store management system, then we won’t do it using client-side JS. But the Node.js can certainly do it as it runs on a server similar to Apache, Django not in a browser.

• AJAX (Aka Asynchronous Javascript And XML) – It is a client-side scripting technique, primarily designed for rendering the contents of a page without refreshing it. There are a number of large companies that utilise AJAX such as Facebook and Stack Overflow to display dynamic content.

• JQuery –It is a famous JavaScript module which complements AJAX, DOM traversal, looping and so on. This library provides many useful functions to help in JavaScript development.

Operation errors are not bugs, but problems with the system, like request timeout or hardware failure. On the other hand programmer errors are actual bugs.

Callback hell is heavily nested callbacks which make the code unreadable and difficult to maintain.

Let’s see an example below.

downloadPhoto(‘http://onlinebags.com/bag.gif’, displayPhoto)

function displayPhoto (error, photo) {

if (error) console.error(‘Loading error!’, error)

else console.log(‘Loading finished’, photo)

}

console.log(‘Loading started’)

Node.js first declares the “displayPhoto” function. After that, it calls the “downloadPhoto” function and pass the “displayPhoto” function as its callback. Finally, the code prints ‘Download started’ on the console. The “displayPhoto” will be executed only after “downloadPhoto” completes the execution of all its tasks.

Node.js internally uses a single-threaded event loop to process queued events. But this approach may lead to blocking the entire process if there is a task running longer than expected.

Node.js addresses this problem by incorporating callbacks also known as higher-order functions. So whenever a long-running process finishes its execution, it triggers the callback associated. With this approach, it can allow the code execution to continue past the long-running task.

However, the above solution looks extremely promising. But sometimes, it could lead to complex and unreadable code. More the number of callbacks, longer the chain of returning callbacks would be.

There are four solutions which can address the callback hell problem.

1. Make Your Program Modular

It proposes to split the logic into smaller modules. And then join them together from the main module to achieve the desired result.

2. Use Async Mechanism

• It is a widely used Node.js module which provides a sequential flow of execution.

• The async module has <async.waterfall> API which passes data from one operation to other using the next callback.

• Another async API <async.map> allows iterating over a list of items in parallel and calls back with another list of results.

• With the async approach, the caller’s callback gets called only once. The caller here is the main method using the async module.

3. Use Promises Mechanism

Promises give an alternate way to write async code. They either return the result of execution or the error/exception. Implementing promises requires the use of <.then()> function which waits for the promise object to return. It takes two optional arguments, both functions. Depending on the state of the promise only one of them will get called. The first function call proceeds if the promise gets fulfilled. However, if the promise gets rejected, then the second function will get called.

4. Use Generators

Generators are lightweight routines, they make a function wait and resume via the yield keyword. Generator functions uses a special syntax <function* ()>. They can also suspend and resume asynchronous operations using constructs such as promises or <thunks> and turn a synchronous code into asynchronous .

The Angular Ahead-of-Time compiler pre-compiles application components and their templates during the build process. Apps compiled with AOT launch faster for several reasons.

• Application components execute immediately, without client-side compilation.

• Templates are embedded as code within their components so there is no client-side request for template files.

• You don’t download the Angular compiler, which is pretty big on its own.

• The compiler discards unused Angular directives that a tree-shaking tool can then exclude.

Redux is a way to manage application state and it offers a single source of truth for the application state, and a unidirectional flow of data change in the application. ngrx/store is one implementation of Redux principles.

Events module in Node.js allows us to create and handle custom events. The Event module contains “EventEmitter” class which can be used to raise and handle custom events. It is accessible via the following code.

// Import events module

var events = require(‘events’);

// Create an eventEmitter object

var eventEmitter = new events.EventEmitter();

When an EventEmitter instance encounters an error, it emits an “error” event. When a new listener gets added, it fires a “newListener” event and when a listener gets removed, it fires a “removeListener” event.

EventEmitter provides multiple properties like “on” and “emit”. The “on” property is used to bind a function to the event and “emit” is used to fire an event.

Stream in Node.js are objects that allows to read data from a source or write data to a specific destination in a continuous fashion. In Node.js, there are four types of streams.

• <Readable> – This is the stream to be used for reading operation.

• <Writable> – It facilitates the write operation.

• <Duplex> – This stream can be used for both the read and write operations.

• <Transform> – It is a form of a duplex stream, which performs the computations based on the available input.

All the streams, discussed above are an instance of an “EventEmitter” class. The event thrown by the Stream varies with time. Some of the commonly used events are as follows.

• <data> – This event gets fired when there is data available for reading.

• <end> – The stream fires this event when there is no more data to read.

• <error> – This event gets fired when there is any error in reading or writing data.

• <finish> – It fires this event after it has flushed all the data to the underlying system.

• A test pyramid about how different kinds of automated tests should be used to create a balanced portfolio.

• Its essential point is that you should have many more low-level UnitTests than high level BroadStackTests running through a GUI.

Following is the list of some of the most commonly used REPL commands.

• <.help> – It displays help for all the commands.

• <tab Keys> – It displays the list of all the available commands.

• <Up/Down Keys> – It will find out what command was executed in REPL previously.

• <.save filename> – Save the current REPL session to a file.

• <.load filename> – To Load the specified file in the current REPL session.

• <ctrl + c> – used to Terminate the current command.

• <ctrl + c (twice)> – To Exit from the REPL.

• <ctrl + d> – This command perfoms Exit from the REPL.

• <.break> – It leads Exitting from multiline expression.

• <.clear> – Exit from multiline expression.

NPM stands for Node Package Manager. It has two main features.

• It works as an Online repository for node.js packages/modules which are present at <nodejs.org>.

• It works as Command line utility to install packages, do version management and dependency management of Node.js packages.

NPM comes bundled along with Node.js installable. We can verify its version using the following command-

$ npm –version

NPM helps to install any Node.js module using the following command.

$ npm install <Module Name>

For example, following is the command to install a famous Node.js web framework module called express-

$ npm install express

A grid system is a structure that allows for content to be stacked both vertically and horizontally in a consistent and easily manageable fashion. Grid systems include two key components: rows and columns.

• Simple Grid

• Pure

• Flexbox Grid

• Bootstrap

• Foundation

• Responsive design works on the principle of flexibility — a single fluid website that can look good on any device. Responsive websites use media queries, flexible grids, and responsive images to create a user experience that flexes and changes based on multiple factors.

• Adaptive design is more like the modern definition of progressive enhancement. Instead of one flexible design, adaptive design detects the device and other features, and then provides the appropriate feature and layout based on a predefined set of viewport sizes and other characteristics. The site detects the type of device used, and delivers the pre-set layout for that device.

A linear search looks down a list, one item at a time, without jumping. In complexity terms, this is an O(n) search – the time taken to search the list gets bigger at the same rate as the list does.

A binary search is when you start with the middle of a sorted list, and see whether that’s greater than or less than the value you’re looking for, which determines whether the value is in the first or second half of the list. Jump to the half way through the sublist, and compare again etc. In complexity terms this is an O(log n) search – the number of search operations grows more slowly than the list does, because you’re halving the “search space” with each operation.

• Binary Search requires the input data to be sorted; linear search doesn’t

• Binary Search requires an ordering comparison; linear search only requires equality comparisons

• Binary Search requires random access to the data; linear search only requires sequential access (this can be very important – it means a linear search can stream data of arbitrary size)

• Yes, Node.js is completely based on a single thread. However, you should be well aware of the fact that it is just a theory behind the design of Node.Js. Apart from being involved in the process of single thread mechanism, it also makes use of callbacks and events to cater to a large number of demands.

• It is also vital for you to note that Node.Js possess an optimized design. This streamlined design allows it to use both C++ and JavaScript resulting in maximum performance. The JavaScript gets executed at the side of the server. On the other hand, the C++ library ensures the processing of non-sequential I/O with the help of background workers.

It is interesting to note that a Node.Js application facilitates the creation of a single thread when it is activated. Whenever the Node.Js receives a request, it first completes the processing before moving onto the next request processing. It is also important to mention here that Node.Js works by using the event loop.

It also uses call back functions and handles multiple requests that are coming from the user. In the working procedure of Node.Js, an event loop always plays an essential role. An event loop is also known as a function which instigates all the event handlers. Hence, lots of works are done on the back-end. It is also important to note that while processing a request, Node.Js usually attaches a call back function. When the response is ready, the event triggers the callback function to send the response to the queries of the user.

• Node.Js makes extensive use of callbacks which enables it to trigger it at the execution of a given task. In this context, it is important to note that a majority of the APIs of the Node.Js is written in such a manner that it supports the feature of callbacks.

• Once the file read procedure gets completed, it would ask the call back function and can pass the contents of the file. Hence, it is evident that there is no wait or blocking due to the existence of the File I/O. This is the reason that the Node.js can be highly scalable as it is involved in processing a higher number of requests without waiting for the function to give back the result that is expected.

In node.js, “non-blocking” implies that its IO is non-blocking. Hub utilizes “libuv” to deal with its IO in a stage rationalist manner. On windows, it utilizes finish ports for UNIX it utilizes epoll or kqueue and so on. Along these lines, it makes a non-blocking demand and upon a demand, it lines it inside the occasion circle which call the JavaScript ‘callback’ on the fundamental JavaScript string.

Dependency injection makes it easy to create loosely coupled components, which typically means that components consume functionality defined by interfaces without having any first-hand knowledge of which implementation classes are being used.

It makes it easier to change the behavior of an application by changing the components that implement the interfaces that define application features. It also results in components that are easier to isolate for unit testing.

The most popular DevOps tools are:

• Git: Version Control System tool

• Jenkins: Continuous Integration tool

• Selenium: Continuous Testing tool

• Puppet, Chef, Ansible: Configuration Management and Deployment tools

• Nagios: Continuous Monitoring tool

• Docker: Containerization tool

Containerisation is a type of virtualization strategy that emerged as an alternative to traditional hypervisor-based virtualization.

In containerization, the operating system is shared by the different containers rather than cloned for each virtual machine. For example Docker provides a container virtualization platform that serves as a good alternative to hypervisor-based arrangements.

In Blue Green Deployment, you have two complete environments. One is Blue environment which is running and the Green environment to which you want to upgrade. Once you swap the environment from blue to green, the traffic is directed to your new green environment. You can delete or save your old blue environment for backup until the green environment is stable.

In Rolling Deployment, you have only one complete environment. The code is deployed in the subset of instances of the same environment and moves to another subset after completion.

• It is a plain JSON (JavaScript Object Notation) text file which contains all metadata information about Node.js Project or application.

• This file should be present in the root directory of every Node.js Package or Module to describe its metadata in JSON format.

• The file is named as “package” because Node.js platform treats every feature as a separate component. Node.js calls these as Package or Module.

• Yes, Node.js would run on a multi-core system without any issue. But it is by default a single-threaded application, so it can’t completely utilize the multi-core system.

• However, Node.js can facilitate deployment on multi-core systems where it does use the additional hardware. It packages with a Cluster module which is capable of starting multiple Node.js worker process that will share the same port.

The main and most important difference between REST and GraphQL is that GraphQL is not dealing with dedicated resources, instead everything is regarded as a graph and therefore is connected and can be queried to app exact needs.

SQL databases store data in form of tables, rows, columns and records. This data is stored in a pre-defined data model which is not very much flexible for today’s real-world highly growing applications. MongoDB in contrast uses a flexible structure which can be easily modified and extended.

• BSON is a binary serialization format used to store documents and make remote procedure calls in MongoDB.

• BSON extends the JSON model to provide additional data types, ordered fields, and to be efficient for encoding and decoding within different languages.

Indexes support the efficient execution of queries in MongoDB. Without indexes, MongoDB must perform a collection scan, i.e. scan every document in a collection, to select those documents that match the query statement. If an appropriate index exists for a query, MongoDB can use the index to limit the number of documents it must inspect.

Aggregations operations process data records and return computed results. Aggregation operations group values from multiple documents together, and can perform a variety of operations on the grouped data to return a single result. MongoDB provides three ways to perform aggregation:

• Aggregation Pipeline

• map-reduce function

• Single purpose aggregation methods and commands

If application has to wait for some I/O operation in order to complete its execution any further then the code responsible for waiting is known as blocking code.

To do so you have more options:

• modularization: break callbacks into independent functions

• use Promises

• use yield with Generators and/or Promises

We use classes as object factories. A class defines a blueprint of what an object should look like and act like and then implements that blueprint by initialising class properties and defining methods. Classes are present throughout all the phases of our code.

Unlike classes, an interface is a virtual structure that only exists within the context of TypeScript. The TypeScript compiler uses interfaces solely for type-checking purposes.

A class may define a factory or a singleton by providing initialisation to its properties and implementation to its methods, an interface is simply a structural contract that defines what the properties of an object should have as a name and as a type.