5.AWP Labmanual New

Ahmedabad Institute of Technology
Computer Engineering Department
Advanced Web Programming(3161611)
Laboratory Manual
Year: 2022-2023
Prepared By: - Prof. Darshana. H. Patel.
Department Vision:
”To produce technically sound and ethically responsible Computer Engineers to the society
by providing Quality Education.”
Department Mission:
To provide healthy Learning Environment based on current and future Industrial demands
To promote curricular, co-curricular and extra-curricular activities for overall personality
development of the students.
To build technically and ethically strong mind having real life problem solving capabilities.
To provide platform for Effective Teaching Learning.
INDEX
Sr. Page No.

No Experiment Date Marks Signature
From To
.
1. Introduction to
HTML,CSS,JavaScript, BootStap
2.ExExpressions in AngularJS
3. Angular JS Forms and Validations

4. Creating single page website
using AngularJS
5. Node JS Concept of Callbacks
6. Node JS File System
7. Networking with Node Node JS
8. Node JS Web Module
9. Connect Node JS with MongoDB
10. Operations on data in MongoDB
Page 2 of 93
EXPERIMENT NO: 1 DATE: / /
TITLE: Introduction to HTML,CSS,JavaScript,BootStap.
OBJECTIVES: On completion of this experiment students will be able to…

➢ know the concept of HTML,CSS,JavaScript,BootStap.
➢ Create a simple Portfolio which shows all your skills.
THEORY:
What is HTML,CSS,JavaScript,Bootstrap:
Bootstrap is the most popular and powerful front-end (HTML, CSS, and JavaScript)
framework for faster and easier responsive web development.
Bootstrap is a powerful front-end framework for faster and easier web development. It
includes HTML and CSS based design templates for creating common user interface
components like forms, buttons, navigations, dropdowns, alerts, modals, tabs,
accordions, carousels, tooltips, and so on.
Bootstrap gives you the ability to create flexible and responsive web layouts with much
less effort.
Bootstrap was originally created by a designer and a developer at Twitter in mid-2010.
Before being an open-sourced framework, Bootstrap was known as Twitter Blueprint.
What You Can Do with Bootstrap
There are a lot more things you can do with Bootstrap.

● You can easily create responsive websites.
● You can quickly create a multi-column layout with predefined classes.
● You can quickly create different types of form layouts.
● You can quickly create different variations of navigation bars.
● You can easily create components like accordions, modals, etc. without writing
any JS code.
● You can easily create dynamic tabs to manage a large amount of content.
● You can easily create tooltips and popovers to show hint text.
● You can easily create a carousel or image slider to showcase your content.
● You can quickly create different types of alert boxes.
Advantages of Using Bootstrap
If you have had some experience with any front-end framework, you might be
wondering what makes Bootstrap so special. Here are some advantages why one should
opt for Bootstrap framework:
Page 3 of 93
● Save lots of time — You can save lots of time and efforts using the Bootstrap
predefined design templates and classes and concentrate on other
development work.
● Responsive features — Using Bootstrap you can easily create responsive
websites that appear more appropriately on different devices and screen
resolutions without any change in markup.
● Consistent design — All Bootstrap components share the same design templates
and styles through a central library, so the design and layout of your web pages
will be consistent.
● Easy to use — Bootstrap is very easy to use. Anybody with the basic working
knowledge of HTML, CSS and JavaScript can start development with Bootstrap.
● Compatible with browsers — Bootstrap is created with modern web browsers in
mind and it is compatible with all modern browsers such as Chrome, Firefox,
Safari, Internet Explorer, etc.
● Open Source — And the best part is, it is completely free to download and use.
Creating Your First Web Page with Bootstrap
Step 1: Creating a Basic HTML file
Open up your favorite code editor and create a new HTML file. Start with an empty
window and type the following code and save it as "basic.html" on your desktop.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-

to-fit=no">
<title>Basic HTML File</title>
</head>
<body>
<h1>Hello, world!</h1>
Page 4 of 93
</body>
</html>
Step 2: Making this HTML File a Bootstrap Template
In order to make this plain HTML file a Bootstrap template, just include the Bootstrap
CSS and JS files as well as required jQuery and Popper.js using their CDN links.
You should include JavaScript files at the bottom of the page, right before the closing
</body> tag to improve the performance of your web pages, as shown in the following
example:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-

to-fit=no">
<title>Basic Bootstrap Template</title>

<link rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.min.c
ss">
</head>
<body>
<h1>Hello, world!</h1>

<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
Page 5 of 93
<script
src="https://cdn.jsdelivr.net/npm/[email protected]/dist/umd/popper.min.js"
></script>
<script
src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js"
></script>
</body>
</html>
And we're all set! After adding the Bootstrap's CSS and JS files and the required jQuery
and Popper.js library, we can begin to develop any site or application with the
Bootstrap framework.
The attributes integrity and crossorigin have been added to CDN links to implement
Subresource Integrity (SRI). It is a security feature that enables you to mitigate the risk
of attacks originating from compromised CDNs, by ensuring that the files your website
fetches (from a CDN or anywhere) have been delivered without unexpected or
malicious modifications. It works by allowing you to provide a cryptographic hash that
a fetched file must match.
Step 3: Saving and Viewing the File
Now save the file on your desktop as "bootstrap-template.html".

To open this file in a web browser, navigate to it, then right click on it, and select your
favorite web browser. Alternatively, you can open your browser and drag this file to it.
EXERCISE:
1.Create Custom components using bootstrap

2. Create Navbars using bootstrap
3.Create Form using bootstrap
4. Create Grid using bootstrap
5. Create bootstrap themes
6. Create student records using CSS and bootstrap.
7. Create your portfolio using HTML,CSS,JavaScript and Bootstrap
Page 6 of 93
EVALUATION:
Understanding /
Involvement Timely
Problem solving Total
Completion
(10)
(4) (3)
(3)
Signature with date: ________________
Page 7 of 93
TITLE: Expressions in AngularJS

➢ know the concept of routers and navigation BootStap.
THEORY:
What is AngularJS
AngularJS is a JavaScript framework. It can be added to an HTML page with a <script>

tag.
AngularJS extends HTML attributes with Directives, and binds data to HTML with
Expressions.
AngularJS is a JavaScript framework written in JavaScript.
AngularJS is distributed as a JavaScript file, and can be added to a web page with a
script tag:
<script
src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.9/angular.min.js"></script>
AngularJS Extends HTML
AngularJS extends HTML with ng-directives.
The ng-app directive defines an AngularJS application.
The ng-model directive binds the value of HTML controls (input, select, textarea) to
application data.
The ng-bind directive binds application data to the HTML view.
<!DOCTYPE html>
<html>
<script
Page 8 of 93
<body>
<div ng-app="">
<p>Name: <input type="text" ng-model="name"></p>
<p ng-bind="name"></p>
</div>
</body>
</html>
AngularJS starts automatically when the web page has loaded.
The ng-app directive tells AngularJS that the <div> element is the "owner" of an
AngularJS application.
The ng-model directive binds the value of the input field to the application variable
name.
The ng-bind directive binds the content of the <p> element to the application variable
name.
AngularJS Expressions
AngularJS expressions can be written inside double braces: {{ expression }}.
AngularJS expressions can also be written inside a directive: ng-bind="expression".
AngularJS will resolve the expression, and return the result exactly where the
expression is written.
AngularJS expressions are much like JavaScript expressions: They can contain literals,
operators, and variables.
Page 9 of 93
Example {{ 5 + 5 }} or {{ firstName + " " + lastName }}
<!DOCTYPE html>
<html>
<script
<body>
<div ng-app="">
<p>My first expression: {{ 5 + 5 }}</p>
</div>
</body>
</html>
EXERCISE:
1.Create Angular JS Application using expression

1.Create Navigation Menu
2. Create inline editor
3.Create Instant Search
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 10 of 93
TITLE: Angular JS Forms and Validations.

➢ know the concept of HTML,CSS,JavaScript,BootStap.
➢ Create a simple Portfolio which shows all your skills.
THEORY:
Forms in AngularJS provide data-binding and validation of input controls.
Input Controls
Input controls are the HTML input elements:
● input elements
● select elements
● button elements
● textarea elements
Data-Binding
Input controls provide data-binding by using the ng-model directive.
<input type="text" ng-model="firstname">
The application does now have a property named firstname.
The ng-model directive binds the input controller to the rest of your application.
The property firstname, can be referred to in a controller:
<!DOCTYPE html>
<html lang="en">
<script
<body>
<div ng-app="myApp" ng-controller="formCtrl">

<form>
First Name: <input type="text" ng-model="firstname">
</form>
</div>
Page 11 of 93
<script>
var app = angular.module('myApp', []);
app.controller('formCtrl', function($scope) {
$scope.firstname = "John";
});
</script>
</body>
</html>
AngularJS can validate input data.

Form Validation
AngularJS offers client-side form validation.
AngularJS monitors the state of the form and input fields (input, textarea, select), and
lets you notify the user about the current state.
AngularJS also holds information about whether they have been touched, or modified,
or not.
You can use standard HTML5 attributes to validate input, or you can make your own
validation functions.
Required
Use the HTML5 attribute required to specify that the input field must be filled out:
<!DOCTYPE html>
<html>
<script
<body ng-app="">
<p>Try writing in the input field:</p>
<form name="myForm">
<input name="myInput" ng-model="myInput" required>
</form>
<p>The input's valid state is:</p>

<h1>{{myForm.myInput.$valid}}</h1>
</body>
</html>
Page 12 of 93
Custom Validation
To create your own validation function is a bit more tricky; You have to add a new
directive to your application, and deal with the validation inside a function with certain
specified arguments.
<!DOCTYPE html>
<html>
<script
<body ng-app="myApp">
<p>Try writing in the input field:</p>
<form name="myForm">
<input name="myInput" ng-model="myInput" required my-directive>
</form>
<p>The input's valid state is:</p>

<h1>{{myForm.myInput.$valid}}</h1>
<script>
app.directive('myDirective', function() {
return {
require: 'ngModel',
link: function(scope, element, attr, mCtrl) {
function myValidation(value) {
if (value.indexOf("e") > -1) {
mCtrl.$setValidity('charE', true);
} else {
mCtrl.$setValidity('charE', false);
}
return value;
}
mCtrl.$parsers.push(myValidation);
}
};
});
</script>
<p>The input field must contain the character "e" to be considered valid.</p>
</body>
</html>
Page 13 of 93
EXERCISE:
1.Create student information form and apply validation
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 14 of 93
TITLE: Creating a single page website using AngularJS.

➢ know the concept of SPA.
THEORY:
What is SPA (Single page application) in AngularJS?
Traditionally, applications were Multi-Page Application (MPA) where with every click a
new page would be loaded from the server. This was not only time consuming but also
increased the server load and made the website slower. AngularJS is a JavaScript-based
front-end web framework based on bidirectional UI data binding and is used to design
Single Page Applications. Single Page Applications are web applications that load a
single HTML page and only a part of the page instead of the entire page gets updated
with every click of the mouse. The page does not reload or transfer control to another
page during the process. This ensures high performance and loading pages faster. Most
modern applications use the concept of SPA. In the SPA, the whole data is sent to the
client from the server at the beginning. As the client clicks certain parts on the webpage,
only the required part of the information is fetched from the server and the page is
rewritten dynamically. This results in a lesser load on the server and is cost-efficient.
SPAs use AJAX and HTML5 to create a fluid and responsive Web applications and most
of the work happens on the client-side. Popular applications such as Facebook, Gmail,
Twitter, Google Drive, Netflix, and many more are examples of SPA.
Advantages:
● Team collaboration
Single-page applications are excellent when more than one developer is
working on the same project. It allows backend developers to focus on the
API, while the frontend developers can focus on creating the user interface
based on the backend API.
● Caching
The application sends a single request to the server and stores all the
received information in the cache. This proves beneficial when the client has
poor network connectivity.
Page 15 of 93
● Fast and responsive
As only parts of the pages are loaded dynamically, it improves the website’s
speed.
● Debugging is easier
Debugging single page applications with chrome is easier since such
applications are developed using like AngularJS Batarang and React
developer tools.
● Linear user experience
Browsing or navigating through the website is easy.
Disadvantages:
● SEO optimization
SPAs provide poor SEO optimization. This is because single-page applications
operate on JavaScript and load data at once from the server. The URL does
not change and different pages do not have a unique URL. Hence it is hard for
the search engines to index the SPA website as opposed to traditional server-
rendered pages.
● Browser history
A SPA does not save the users’ transition of states within the website. A
browser saves the previous pages only, not the state transition. Thus when
users click the back button, they are not redirected to the previous state of
the website. To solve this problem, developers can equip their SPA
frameworks with the HTML5 History API.
● Security issues
Single-page apps are less immune to cross-site scripting (XSS) and since no
new pages are loaded, hackers can easily gain access to the website and
inject new scripts on the client-side.
● Memory Consumption
Since the SPA can run for a long time, sometimes hours at a time, one needs
Page 16 of 93
to make sure the application does not consume more memory than it needs.
Else, users with low memory devices may face serious performance issues.
● Disabled Javascript
Developers need to chalk out ideas for users to access the information on the
website for browsers that have Javascript disabled.
When to use SPA?
SPAs are good when the volume of data is small and the website that needs a dynamic
platform. It is also a good option for mobile applications. But businesses that depend
largely on search engine optimizations such as e-commerce applications must avoid
single-page applications and opt for MPAs.
<!DOCTYPE html>

<html ng-app="myApp">
<head>

<script src=
"https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular.min.js">
</script>
<script src=
"https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular-route.min.js">
</script>
</head>
<body>

<script type="text/ng-template"
id="first.html">
<h1>First Page</h1>
<h2 style="color:green">
Welcome to AIT
</h2>
<h3>{{message}}</h3>
</script>
id="second.html">
Page 17 of 93
<h1>Second Page</h1>
Start Learning With GFG
</h2>
</script>
id="third.html">
<h1>Third Page</h1>
Know about us
</h2>
</script>

<a href="#/">First</a>
<a href="#/second">Second</a>
<a href="#/third">Third</a>

<div ng-view></div>
<script>
var app = angular.module('myApp', ['ngRoute']);
app.config(function($routeProvider) {
$routeProvider
.when('/', {
templateUrl : 'first.html',
controller : 'FirstController'
})
.when('/second', {
templateUrl : 'second.html',
controller : 'SecondController'
})
.when('/third', {
templateUrl : 'third.html',
controller : 'ThirdController'
})
.otherwise({redirectTo: '/'});
});
Page 18 of 93


app.controller('FirstController', function($scope) {
$scope.message = 'Hello from FirstController';
});
app.controller('SecondController', function($scope) {
$scope.message = 'Hello from SecondController';
});
app.controller('ThirdController', function($scope) {
$scope.message = 'Hello from ThirdController';
});
</script>
</body>
</html>
EXERCISE:
1.Create Single Page Application in Angular JS.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 19 of 93
TITLE: Node JS Concept.

➢ know the concept of Node JS.
THEORY:
● Node.js is an open source server environment

● Node.js is free
● Node.js runs on various platforms (Windows, Linux, Unix, Mac OS X, etc.)
● Node.js uses JavaScript on the server
A common task for a web server can be to open a file on the server and return the content to the
client.
Here is how PHP or ASP handles a file request:
1. Sends the task to the computer's file system.

2. Waits while the file system opens and reads the file.
3. Returns the content to the client.
4. Ready to handle the next request.
Here is how Node.js handles a file request:
1. Sends the task to the computer's file system.

2. Ready to handle the next request.
3. When the file system has opened and read the file, the server returns the content to
the client.
Node.js eliminates the waiting, and simply continues with the next request.
Node.js runs single-threaded, non-blocking, asynchronously programming, which is very memory

efficient.
What Can Node.js Do?
● Node.js can generate dynamic page content

● Node.js can create, open, read, write, delete, and close files on the server
● Node.js can collect form data
● Node.js can add, delete, modify data in your database
Page 20 of 93
What is a Node.js File?
● Node.js files contain tasks that will be executed on certain events

● A typical event is someone trying to access a port on the server
● Node.js files must be initiated on the server before having any effect
● Node.js files have extension ".js"
●
Node.js Modules
What is a Module in Node.js?
Consider modules to be the same as JavaScript libraries.
A set of functions you want to include in your application.
Built-in Modules
Node.js has a set of built-in modules which you can use without any further installation.
Node.js has a set of built-in modules which you can use without any further installation.
Here is a list of the built-in modules of Node.js version 6.10.3:
Module Description
assert Provides a set of assertion tests
buffer To handle binary data
child_process To run a child process
cluster To split a single Node process into multiple processes
Page 21 of 93
crypto To handle OpenSSL cryptographic functions
dgram Provides implementation of UDP datagram sockets
dns To do DNS lookups and name resolution functions
domain Deprecated. To handle unhandled errors
events To handle events
fs To handle the file system
http To make Node.js act as an HTTP server
https To make Node.js act as an HTTPS server.
net To create servers and clients
os Provides information about the operation system
path To handle file paths
Page 22 of 93
punycode Deprecated. A character encoding scheme
querystring To handle URL query strings
readline To handle readable streams one line at the time
stream To handle streaming data
string_decoder To decode buffer objects into strings
timers To execute a function after a given number of milliseconds
tls To implement TLS and SSL protocols
tty Provides classes used by a text terminal
url To parse URL strings
util To access utility functions
v8 To access information about V8 (the JavaScript engine)
Page 23 of 93
vm To compile JavaScript code in a virtual machine
zlib To compress or decompress files
include Modules
To include a module, use the require() function with the name of the module:
var http = require('http');
Now your application has access to the HTTP module, and is able to create a server:
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.end('Hello World!');
}).listen(8080);
Create Your Own Modules
You can create your own modules, and easily include them in your applications.
The following example creates a module that returns a date and time object:
Example
Create a module that returns the current date and time:
exports.myDateTime = function () {
return Date();
};
Use the exports keyword to make properties and methods available outside the module
file.
Page 24 of 93
Save the code above in a file called "myfirstmodule.js"
Include Your Own Module
Now you can include and use the module in any of your Node.js files.
App.js

var dt = require('./myfirstmodule');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write("The date and time is currently: " + dt.myDateTime());
res.end();
}).listen(8080);
Notice that we use ./ to locate the module, that means that the module is located in the
same folder as the Node.js file.
Save the code above in a file called "demo_module.js", and initiate the file:
Initiate demo_module.js:
C:\Users\Your Name>node demo_module.js
If you have followed the same steps on your computer, you will see the same result as
the example: http://localhost:8080
EXERCISE:
1.Create Node.JS callback Application.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 25 of 93
TITLE: Node JS File System

➢ know the concept of File System and related operations
THEORY:
Node implements File I/O using simple wrappers around standard
POSIX functions. The Node File System (fs) module can be imported
using the following syntax −
var fs = require("fs")
Synchronous vs Asynchronous
Every method in the fs module has synchronous as well as asynchronous forms.
Asynchronous methods take the last parameter as the completion function callback
and the first parameter of the callback function as error. It is better to use an
asynchronous method instead of a synchronous method, as the former never blocks a
program during its execution, whereas the second one does.
Example
Create a text file named input.txt with the following content −
Ahmedabad Institute of technology is giving learning content
to teach the world in simple and easy way!!!!!
------------------------------------------------------------------------------------------------------
Let us create a js file named main.js with the following code −
var fs = require("fs");
Page 26 of 93
// Asynchronous read
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
console.log("Asynchronous read: " + data.toString());
});
// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");
Now run the main.js to see the result −
$ node main.js
Verify the Output.
Synchronous read:Ahmedabad Institute of technology is giving learning content
Program Ended
Asynchronous read: Ahmedabad Institute of technology is giving learning content
Page 27 of 93
● Open a File
Syntax
Following is the syntax of the method to open a file in asynchronous
mode −
fs.open(path, flags[, mode], callback)
Parameters
Here is the description of the parameters used −
● path − This is the string having file name including path.
● flags − Flags indicate the behavior of the file to be opened. All
possible values have been mentioned below.
● mode − It sets the file mode (permission and sticky bits), but only if
the file was created. It defaults to 0666, readable and writeable.
● callback − This is the callback function which gets two arguments
(err, fd).
Flags
Flags for read/write operations are −
Sr.No. Flag & Description
r :Open file for reading. An exception occurs if the file does not exist.
1
r+:Open file for reading and writing. An exception occurs if the file does not
2
Page 28 of 93
exist.
rs:Open file for reading in synchronous mode.

3
rs+:Open file for reading and writing, asking the OS to open it synchronously.
4
See notes for 'rs' about using this with caution.
w:Open file for writing. The file is created (if it does not exist) or truncated (if it
5
exists).
wx:Like 'w' but fails if the path exists.

6
w+:Open file for reading and writing. The file is created (if it does not exist) or
7
truncated (if it exists).
wx+:Like 'w+' but fails if path exists.

8
a:Open file for appending. The file is created if it does not exist.
9
Page 29 of 93
ax:Like 'a' but fails if the path exists.
10
a+:Open file for reading and appending. The file is created if it does not exist.
11
ax+:Like 'a+' but fails if the the path exists.

12
Example
Let us create a js file named main.js having the following code to open a file input.txt
for reading and writing.
// Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
if (err) {
console.log("File opened successfully!");
});
Page 30 of 93
$ node main.js
Verify the Output.
Going to open file!
File opened successfully!
--------------------------------------------------------------------------------------------------------
Get File Information
Syntax
Following is the syntax of the method to get the information about a file
fs.stat(path, callback)
Parameters
● path − This is the string having file name including path.
(err, stats) where stats is an object of fs.Stats type which is printed
below in the example.
Apart from the important attributes which are printed below in the example, there are
several useful methods available in fs.Stats class which can be used to check file type.
These methods are given in the following table.
Page 31 of 93
Sr.No. Method & Description
stats.isFile()
1
Returns true if file type of a simple file.
stats.isDirectory()
2
Returns true if file type of a directory.
stats.isBlockDevice()
3
Returns true if file type of a block device.
stats.isCharacterDevice()
4
Returns true if file type of a character device.
stats.isSymbolicLink()
5
Returns true if file type of a symbolic link.
stats.isFIFO()
6
Page 32 of 93
Returns true if file type of a FIFO.
stats.isSocket()
7
Returns true if file type of a socket.
Example
console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
if (err) {
console.log(stats);
console.log("Got file info successfully!");
// Check file type
console.log("isFile ? " + stats.isFile());
console.log("isDirectory ? " + stats.isDirectory());
});
Page 33 of 93
$ node main.js
Verify the Output.
Going to get file info!
dev: 1792,
mode: 33188,
nlink: 1,
uid: 48,
gid: 48,
rdev: 0,
blksize: 4096,
ino: 4318127,
size: 97,
blocks: 8,
atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT)
Page 34 of 93
Got file info successfully!
isFile ? true
isDirectory ? false
--------------------------------------------------------------------------------------------------------
Writing a File
Syntax
Following is the syntax of one of the methods to write into a file −
fs.writeFile(filename, data[, options], callback)
This method will over-write the file if the file already exists. If you want to write into
an existing file then you should use another method available.
Parameters
● path − This is the string having the file name including path.
● data − This is the String or Buffer to be written into the file.
● options − The third parameter is an object which will hold
{encoding, mode, flag}. By default. encoding is utf8, mode is octal
value 0666. and flag is 'w'
● callback − This is the callback function which gets a single
parameter err that returns an error in case of any writing error.
Example
Let us create a js file named main.js having the following code −
Page 35 of 93
console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {
if (err) {
console.log("Data written successfully!");
console.log("Let's read newly written data");
fs.readFile('input.txt', function (err, data) {
if (err) {
console.log("Asynchronous read: " + data.toString());
});
});
$ node main.js
Verify the Output.
Going to write into existing file
Page 36 of 93
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!
--------------------------------------------------------------------------------------------------------
Reading a File
Syntax
Following is the syntax of one of the methods to read from a file −
fs.read(fd, buffer, offset, length, position, callback)
This method will use file descriptor to read the file. If you want to read the file directly
using the file name, then you should use another method available.
Parameters
● fd − This is the file descriptor returned by fs.open().
● buffer − This is the buffer that the data will be written to.
● offset − This is the offset in the buffer to start writing at.
● length − This is an integer specifying the number of bytes to read.
● position − This is an integer specifying where to begin reading from
in the file. If position is null, data will be read from the current file
position.
● callback − This is the callback function which gets the three
arguments, (err, bytesRead, buffer).
Example
Page 37 of 93
var buf = new Buffer(1024);
console.log("Going to open an existing file");
if (err) {
console.log("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err){
console.log(err);
console.log(bytes + " bytes read");
// Print only read bytes to avoid junk.
if(bytes > 0){
console.log(buf.slice(0, bytes).toString());
Page 38 of 93
});
});
$ node main.js
Verify the Output.
Going to open an existing file
Going to read the file
97 bytes read
Ahmedabad Institute Of Technology is giving self learning content
--------------------------------------------------------------------------------------------------------
Closing a File
Syntax
Following is the syntax to close an opened file −
fs.close(fd, callback)
Parameters
● fd − This is the file descriptor returned by file fs.open() method.
Page 39 of 93
● callback − This is the callback function No arguments other than a
possible exception are given to the completion callback.
Example
if (err) {
console.log("Going to read the file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
if (err) {
console.log(err);
if(bytes > 0) {
Page 40 of 93
}
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
console.log("File closed successfully.");
});
});
});
$ node main.js
Verify the Output.
Going to read the file
Ahmedabad Institute Of Technology is giving self learning content
File closed successfully.
Page 41 of 93
--------------------------------------------------------------------------------------------------------
Truncate a File
Syntax
Following is the syntax of the method to truncate an opened file −
fs.ftruncate(fd, len, callback)
Parameters
● fd − This is the file descriptor returned by fs.open().
● len − This is the length of the file after which the file will be
truncated.
Example
if (err) {
Page 42 of 93
}
console.log("Going to truncate the file after 10 bytes");
// Truncate the opened file.
fs.ftruncate(fd, 10, function(err) {
if (err) {
console.log(err);
console.log("File truncated successfully.");
console.log("Going to read the same file");
fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
if (err) {
console.log(err);
if(bytes > 0) {
Page 43 of 93
// Close the opened file.
fs.close(fd, function(err) {
if (err) {
console.log(err);
console.log("File closed successfully.");
});
});
});
});
$ node main.js
Verify the Output.
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Page 44 of 93
Ahmedabad Institute Of Tecnology
File closed successfully.
--------------------------------------------------------------------------------------------------------
Delete a File
Syntax
Following is the syntax of the method to delete a file −
fs.unlink(path, callback)
Parameters
● path − This is the file name including path.
Example
console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
if (err) {
console.log("File deleted successfully!");
Page 45 of 93
});
$ node main.js
Verify the Output.
Going to delete an existing file
File deleted successfully!
--------------------------------------------------------------------------------------------------------
Create a Directory
Syntax
Following is the syntax of the method to create a directory −
fs.mkdir(path[, mode], callback)
Parameters
● path − This is the directory name including path.
● mode − This is the directory permission to be set. Defaults to 0777.
Example
Page 46 of 93
console.log("Going to create directory /tmp/test");
fs.mkdir('/tmp/test',function(err) {
if (err) {
console.log("Directory created successfully!");
});
$ node main.js
Verify the Output.
Going to create directory /tmp/test
Directory created successfully!
--------------------------------------------------------------------------------------------------------
Read a Directory
Syntax
Following is the syntax of the method to read a directory −
fs.readdir(path, callback)
Parameters
Page 47 of 93
(err, files) where files is an array of the names of the files in the
directory excluding '.' and '..'.
Example
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
files.forEach( function (file) {
console.log( file );
});
});
$ node main.js
Verify the Output.
Going to read directory /tmp
ccmzx99o.out
Page 48 of 93
ccyCSbkF.out
employee.ser
hsperfdata_apache
test
test.txt
--------------------------------------------------------------------------------------------------------
Remove a Directory
Syntax
Following is the syntax of the method to remove a directory −
fs.rmdir(path, callback)
Parameters
Example
console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err) {
Page 49 of 93
if (err) {
console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
if (err) {
files.forEach( function (file) {
console.log( file );
});
});
});
$ node main.js
Verify the Output.
Going to read directory /tmp
employee.ser
hsperfdata_apache
Page 50 of 93
EXERCISE:
1.Create Node.js Application to show all File operations.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 51 of 93
TITLE: Networking with Node Node JS

➢ know the concept of Socket Programming
THEORY:
Node.js provides the ability to perform socket programming. We can create chat
application or communicate client and server applications using socket programming in
Node.js. The Node.js net module contains functions for creating both servers and clients.
Node.js net module is used to create both servers and clients. This module provides an
asynchronous network wrapper and it can be imported using the following syntax.
var net = require("net")
Methods
1 net.createServer([options][, connectionListener]).Creates a new TCP

server. The connectionListener argument is automatically set as a listener
for the 'connection' event.
2 net.connect(options[, connectionListener]).A factory method, which

returns a new 'net.Socket' and connects to the supplied address and port.
3 net.createConnection(options[, connectionListener]).A factory method,

which returns a new 'net.Socket' and connects to the supplied address and
port.
Page 52 of 93
4 net.connect(port[, host][, connectListener]).Creates a TCP connection to
port on host. If host is omitted, 'localhost' will be assumed. The
connectListener parameter will be added as a listener for the 'connect'
event. It is a factory method which returns a new 'net.Socket'.
5 net.createConnection(port[, host][, connectListener]).Creates a TCP

connection to port on host. If host is omitted, 'localhost' will be assumed.
The connectListener parameter will be added as a listener for the 'connect'
event. It is a factory method which returns a new 'net.Socket'.
6 net.connect(path[, connectListener]).Creates Unix socket connection to

path. The connectListener parameter will be added as a listener for the
'connect' event. It is a factory method which returns a new 'net.Socket'.
7 net.createConnection(path[, connectListener]).Creates Unix socket

connection to path. The connectListener parameter will be added as a
listener for the 'connect' event. It is a factory method which returns a new
'net.Socket'.
8 net.isIP(input).Tests if the input is an IP address. Returns 0 for invalid

strings, 4 for IP version 4 addresses, and 6 for IP version 6 addresses.
9 net.isIPv4(input).Returns true if the input is a version 4 IP address,

otherwise returns false.
Page 53 of 93
10 net.isIPv6(input).Returns true if the input is a version 6 IP address,
otherwise returns false.
Class - net.Server
This class is used to create a TCP or local server.
Methods
1 server.listen(port[, host][, backlog][, callback])
Begin accepting connections on the specified port and host. If the host is
omitted, the server will accept connections directed to any IPv4 address
(INADDR_ANY). A port value of zero will assign a random port.
2 server.listen(path[, callback])
Start a local socket server listening for connections on the given path.
3 server.listen(handle[, callback])
The handle object can be set to either a server or socket (anything with an
underlying _handle member), or a {fd: <n>} object. It will cause the server to
accept connections on the specified handle, but it is presumed that the file
descriptor or handle has already been bound to a port or domain socket.
Listening on a file descriptor is not supported on Windows.
Page 54 of 93
4 server.listen(options[, callback])
The port, host, and backlog properties of options, as well as the optional
callback function, behave as they do on a call to server.listen(port, [host],
[backlog], [callback]) . Alternatively, the path option can be used to specify a
UNIX socket.
5 server.close([callback])
Finally closed when all connections are ended and the server emits a 'close'
event.
6 server.address()
Returns the bound address, the address family name and port of the server as
reported by the operating system.
7 server.unref()
Calling unref on a server will allow the program to exit if this is the only active
server in the event system. If the server is already unrefd, then calling unref
again will have no effect.
Page 55 of 93
8 server.ref()
Opposite of unref, calling ref on a previously unrefd server will not let the
program exit if it's the only server left (the default behavior). If the server is
refd, then calling the ref again will have no effect.
9 server.getConnections(callback)
Asynchronously get the number of concurrent connections on the server.

Works when sockets were sent to forks. Callback should take two arguments
err and count.
Events
Sr.No. Events & Description
1 listening
Emitted when the server has been bound after calling server.listen.
2 connection
Emitted when a new connection is made. Socket object, the connection

object is available to event handler. Socket is an instance of net.Socket.
Page 56 of 93
3 close
Emitted when the server closes. Note that if connections exist, this event is
not emitted until all the connections are ended.
4 error
Emitted when an error occurs. The 'close' event will be called directly
following this event.
Class - net.Socket
This object is an abstraction of a TCP or local socket. net.Socket instances implement a
duplex Stream interface. They can be created by the user and used as a client (with
connect()) or they can be created by Node and passed to the user through the
'connection' event of a server.
Events
net.Socket is an eventEmitter and it emits the following events.
Sr.No. Events & Description
1 lookup
Emitted after resolving the hostname but before connecting. Not applicable
to UNIX sockets.
2 connect
Page 57 of 93
Emitted when a socket connection is successfully established.
3 data
Emitted when data is received. The argument data will be a Buffer or String.
Encoding of data is set by socket.setEncoding().
4 end
Emitted when the other end of the socket sends a FIN packet.
5 timeout
Emitted if the socket times out from inactivity. This is only to notify that the
socket has been idle. The user must manually close the connection.
6 drain
Emitted when the write buffer becomes empty. Can be used to throttle
uploads.
7 error
Emitted when an error occurs. The 'close' event will be called directly
Page 58 of 93
following this event.
8 close
Emitted once the socket is fully closed. The argument had_error is a boolean
which indicates if the socket was closed due to a transmission error.
Properties
net.Socket provides many useful properties to get better control over socket
interactions.
Sr.No. Property & Description
1 socket.bufferSize
This property shows the number of characters currently buffered to be

written.
2 socket.remoteAddress
The string representation of the remote IP address. For example,

'74.125.127.100' or '2001:4860:a005::68'.
Page 59 of 93
3 socket.remoteFamily
The string representation of the remote IP family. 'IPv4' or 'IPv6'.
4 socket.remotePort
The numeric representation of the remote port. For example, 80 or 21.
5 socket.localAddress
The string representation of the local IP address the remote client is

connecting on. For example, if you are listening on '0.0.0.0' and the client
connects on '192.168.1.1', the value would be '192.168.1.1'.
6 socket.localPort
The numeric representation of the local port. For example, 80 or 21.
7 socket.bytesRead
The amount of received bytes.
8 socket.bytesWritten
Page 60 of 93
The amount of bytes sent.
Methods
1 new net.Socket([options])
Construct a new socket object.
2 socket.connect(port[, host][, connectListener])
Opens the connection for a given socket. If port and host are given, then the
socket will be opened as a TCP socket, if host is omitted, localhost will be
assumed. If a path is given, the socket will be opened as a Unix socket to
that path.
3 socket.connect(path[, connectListener])
Opens the connection for a given socket. If port and host are given, then the
socket will be opened as a TCP socket, if host is omitted, localhost will be
assumed. If a path is given, the socket will be opened as a Unix socket to
that path.
4 socket.setEncoding([encoding])
Page 61 of 93
Set the encoding for the socket as a Readable Stream.
5 socket.write(data[, encoding][, callback])
Sends data on the socket. The second parameter specifies the encoding in
the case of a string--it defaults to UTF8 encoding.
6 socket.end([data][, encoding])
Half-closes the socket, i.e., it sends a FIN packet. It is possible the server will
still send some data.
7 socket.destroy()
Ensures that no more I/O activity happens on this socket. Necessary only in
case of errors (parse error or so).
8 socket.pause()
Pauses the reading of data. That is, 'data' events will not be emitted. Useful
to throttle back an upload.
9 socket.resume()
Page 62 of 93
Resumes reading after a call to pause().
10 socket.setTimeout(timeout[, callback])
Sets the socket to timeout after timeout milliseconds of inactivity on the

socket. By default, net.Socket does not have a timeout.
11 socket.setNoDelay([noDelay])
Disables the Nagle algorithm. By default, TCP connections use the Nagle
algorithm, they buffer data before sending it off. Setting true for noDelay
will immediately fire off data each time socket.write() is called. noDelay
defaults to true.
12 socket.setKeepAlive([enable][, initialDelay])
Enable/disable keep-alive functionality, and optionally set the initial delay

before the first keepalive probe is sent on an idle socket. enable defaults to
false.
13 socket.address()
Returns the bound address, the address family name, and the port of the
socket as reported by the operating system. Returns an object with three
properties, e.g. { port: 12346, family: 'IPv4', address: '127.0.0.1' }.
Page 63 of 93
14 socket.unref()
Calling unref on a socket will allow the program to exit if this is the only
active socket in the event system. If the socket is already unrefd, then
calling unref again will have no effect.
15 socket.ref()
Opposite of unref, calling ref on a previously unrefd socket will not let the
program exit if it's the only socket left (the default behavior). If the socket is
refd, then calling ref again will have no effect.
Node.js Net Example
In this example, we are using two command prompts:
● Node.js command prompt for server.
● Window's default command prompt for client.
Server:
File: net_server1.js
var net = require('net');
var server = net.createServer(function(connection) {
console.log('client connected');
connection.on('end', function() {
Page 64 of 93
console.log('client disconnected');
});
connection.write('Hello World!\r\n');
connection.pipe(connection);
});
server.listen(8080, function() {
console.log('server is listening');
});
Open Node.js command prompt and run the following code:
node net_server.js
client:
File: net_client1.js
var net = require('net');
var client = net.connect({port: 8080}, function() {
console.log('connected to server!');
});
client.on('data', function(data) {
console.log(data.toString());
client.end();
});
client.on('end', function() {
Page 65 of 93
console.log('disconnected from server');
});
Open Node.js command prompt and run the following code:
node net_client.js
Verify the Output.
connected to server!
Hello World!
disconnected from server
Verify the Output on the terminal where server.js is running.
server is listening
client connected
client disconnected
EXERCISE:
1.Create Node.js Application to show client server communication.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 66 of 93
TITLE: Node JS Web Module

➢ know the concept of the web module and architecture of it.
THEORY:
What is a Web Server?

A Web Server is a software application which handles HTTP requests sent by the HTTP
client, like web browsers, and returns web pages in response to the clients. Web
servers usually deliver html documents along with images, style sheets, and scripts.
Most of the web servers support server-side scripts, using scripting languages or
redirecting the task to an application server which retrieves data from a database and
performs complex logic and then sends a result to the HTTP client through the Web
server.
Apache web server is one of the most commonly used web servers. It is an open source
project.
Web Application Architecture
A Web application is usually divided into four layers −
Page 67 of 93
● Client − This layer consists of web browsers, mobile browsers or
applications which can make HTTP requests to the web server.
● Server − This layer has the Web server which can intercept the
requests made by the clients and pass them the response.
● Business − This layer contains the application server which is
utilized by the web server to do the required processing. This layer
interacts with the data layer via the database or some external
programs.
● Data − This layer contains the databases or any other source of
data.
Creating a Web Server using Node

Node.js provides an http module which can be used to create an HTTP client of a server.
Following is the bare minimum structure of the HTTP server which listens at 8081 port.
Create a js file named server.js −
File: server.js
var fs = require('fs');
var url = require('url');
// Create a server
http.createServer( function (request, response) {
// Parse the request containing file name
var pathname = url.parse(request.url).pathname;
Page 68 of 93
// Print the name of the file for which request is made.
console.log("Request for " + pathname + " received.");
// Read the requested file content from file system
fs.readFile(pathname.substr(1), function (err, data) {
if (err) {
console.log(err)
// HTTP Status: 404 : NOT FOUND
// Content Type: text/plain
response.writeHead(404, {'Content-Type': 'text/html'});
} else {
//Page found
// HTTP Status: 200 : OK
// Content Type: text/plain
response.writeHead(200, {'Content-Type': 'text/html'});
// Write the content of the file to response body
response.write(data.toString());
// Send the response body
response.end();
Page 69 of 93
});
}).listen(8081);
// Console will print the message
console.log('Server running at http://127.0.0.1:8081/');
Next let's create the following html file named index.htm in the same directory where
you created server.js.
File: index.htm
<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
</body>
</html>
Now let us run the server.js to see the result −
$ node server.js
Verify the Output.
Server running at http://127.0.0.1:8081/
Page 70 of 93
Make a request to Node.js server
Open http://127.0.0.1:8081/index.html in any browser to see the following

result.
Creating Web client using Node

A web client can be created using http module. Let's check the following example.
Create a js file named client.js −
File: client.js
// Options to be used by request
var options = {
host: 'localhost',
port: '8081',
path: '/index.html'
};
// Callback function is used to deal with response
var callback = function(response) {
// Continuously update stream with data
var body = '';
response.on('data', function(data) {
body += data;
Page 71 of 93
});
response.on('end', function() {
// Data received completely.
console.log(body);
});
// Make a request to the server
var req = http.request(options, callback);
req.end();
Now run the client.js from a different command terminal other than
server.js to see the result −
$ node client.js
Verify the Output.
<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
Page 72 of 93
</body>
</html>
Verify the Output at server end.
Server running at http://127.0.0.1:8081/
Request for /index.htm received.
EXERCISE:
1.Create Node.js Application to run on web client as well as server.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 73 of 93
TITLE: MongoDB with NodeJs

➢ know the concept of Connectivity of MongoDB with Nodejs
THEORY:
Install MongoDB :
You can download a free MongoDB database at https://www.mongodb.com.
Or get started right away with a MongoDB cloud service at

https://www.mongodb.com/cloud/atlas.
Let us try to access a MongoDB database with Node.js.
To download and install the official MongoDB driver, open the Command Terminal and
execute the following:
Download and install mongodb package:

C:\Users\Your Name>npm install mongodb
Note: First open another terminal an run command mongod to start your mongoDB
Node.js MongoDB Create Database
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/mydb";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
console.log("Database created!");
db.close();
Page 74 of 93
});
C:\Users>node demo_create_mongo_db.js
Node.js MongoDB Create Collection:
A collection in MongoDB is the same as a table in MySQL
Creating a Collection
To create a collection in MongoDB, use the createCollection() method:
Example
Create a collection called "customers":
var url = "mongodb://localhost:27017/";
if (err) throw err;
var dbo = db.db("mydb");
dbo.createCollection("customers", function(err, res) {
if (err) throw err;
console.log("Collection created!");
db.close();
});
});
Page 75 of 93
EXERCISE:
1.Create Node.js Application to Connect Node JS with MongoDB
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 76 of 93
TITLE: Operations on data in MongoDB

➢ MongoDB and operations like (Insert, Find, Query, Sort, Delete,
Update)
THEORY:
To insert a record, or document as it is called in MongoDB, into a collection, we use the

insertOne() method.
A document in MongoDB is the same as a record in MySQL
The first parameter of the insertOne() method is an object containing the name(s) and
value(s) of each field in the document you want to insert.
It also takes a callback function where you can work with any errors, or the result of the
insertion:
Example
Insert a document in the "customers" collection:
if (err) throw err;
var myobj = { name: "Company Inc", address: "Highway 37" };
dbo.collection("customers").insertOne(myobj, function(err, res) {
Page 77 of 93
if (err) throw err;
console.log("1 document inserted");
db.close();
});
});
Insert Multiple Documents
To insert multiple documents into a collection in MongoDB, we use the insertMany()

method.
The first parameter of the insertMany() method is an array of objects, containing the
data you want to insert.
It also takes a callback function where you can work with any errors, or the result of the
insertion:
Example
Insert multiple documents in the "customers" collection:
if (err) throw err;
var myobj = [
{ name: 'John', address: 'Highway 71'},
Page 78 of 93
{ name: 'Peter', address: 'Lowstreet 4'},
{ name: 'Amy', address: 'Apple st 652'},
{ name: 'Hannah', address: 'Mountain 21'},
{ name: 'Michael', address: 'Valley 345'},
{ name: 'Sandy', address: 'Ocean blvd 2'},
{ name: 'Betty', address: 'Green Grass 1'},
{ name: 'Richard', address: 'Sky st 331'},
{ name: 'Susan', address: 'One way 98'},
{ name: 'Vicky', address: 'Yellow Garden 2'},
{ name: 'Ben', address: 'Park Lane 38'},
{ name: 'William', address: 'Central st 954'},
{ name: 'Chuck', address: 'Main Road 989'},
{ name: 'Viola', address: 'Sideway 1633'}
];
dbo.collection("customers").insertMany(myobj, function(err, res) {
if (err) throw err;
console.log("Number of documents inserted: " + res.insertedCount);
db.close();
});
Page 79 of 93
});
The _id Field
If you do not specify an _id field, then MongoDB will add one for you and assign a
unique id for each document.
In the example above no _id field was specified, and as you can see from the result
object, MongoDB assigned a unique _id for each document.
If you do specify the _id field, the value must be unique for each document:
Example
Insert three records in a "products" table, with specified _id fields:
if (err) throw err;
var myobj = [
{ _id: 154, name: 'Chocolate Heaven'},
{ _id: 155, name: 'Tasty Lemon'},
{ _id: 156, name: 'Vanilla Dream'}
];
dbo.collection("products").insertMany(myobj, function(err, res) {
if (err) throw err;
Page 80 of 93
console.log(res);
db.close();
});
});
Node.js MongoDB Find

In MongoDB we use the find and findOne methods to find data in a collection.
Just like the SELECT statement is used to find data in a table in a MySQL database.
Find One
To select data from a collection in MongoDB, we can use the findOne() method.
The findOne() method returns the first occurrence in the selection.
The first parameter of the findOne() method is a query object. In this example we use an
empty query object, which selects all documents in a collection (but returns only the
first document).
Example
Find the first document in the customers collection:
if (err) throw err;
dbo.collection("customers").findOne({}, function(err, result) {
if (err) throw err;
console.log(result.name);
Page 81 of 93
db.close();
});
});
Find All
To select data from a table in MongoDB, we can also use the find() method.
The find() method returns all occurrences in the selection.
The first parameter of the find() method is a query object. In this example we use an
empty query object, which selects all documents in the collection.
No parameters in the find() method gives you the same result as SELECT * in MySQL.
Example
Find all documents in the customers collection:
if (err) throw err;
dbo.collection("customers").find({}).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
Page 82 of 93
});
Find Some
The second parameter of the find() method is the projection object that describes which
fields to include in the result.
This parameter is optional, and if omitted, all fields will be included in the result.
Example
Return the fields "name" and "address" of all documents in the customers collection:
if (err) throw err;
dbo.collection("customers").find({}, { projection: { _id: 0, name: 1, address:

1 } }).toArray(function(err, result) {
if (err) throw err;
db.close();
});
});
Node.js MongoDB Query

Filter the Result
When finding documents in a collection, you can filter the result by using a query object.
Page 83 of 93
The first argument of the find() method is a query object, and is used to limit the search.
Example
Find documents with the address "Park Lane 38":
if (err) throw err;
var query = { address: "Park Lane 38" };
dbo.collection("customers").find(query).toArray(function(err, result) {
if (err) throw err;
db.close();
});
});
Filter With Regular Expressions
You can write regular expressions to find exactly what you are searching for.
Regular expressions can only be used to query strings.
To find only the documents where the "address" field starts with the letter "S", use the
regular expression /^S/:
Example
Find documents where the address starts with the letter "S":
Page 84 of 93
if (err) throw err;
var query = { address: /^S/ };
dbo.collection("customers").find(query).toArray(function(err, result) {
if (err) throw err;
db.close();
});
});
Node.js MongoDB Sort

Sort the Result
Use the sort() method to sort the result in ascending or descending order.
The sort() method takes one parameter, an object defining the sorting order.
Example
Sort the result alphabetically by name:
if (err) throw err;
Page 85 of 93
var mysort = { name: 1 };
dbo.collection("customers").find().sort(mysort).toArray(function(err, result) {
if (err) throw err;
db.close();
});
});
Sort Descending
Example
Sort the result reverse alphabetically by name:
if (err) throw err;
var mysort = { name: -1 };
dbo.collection("customers").find().sort(mysort).toArray(function(err, result) {
if (err) throw err;
db.close();
Page 86 of 93
});
});
Node.js MongoDB Delete

Delete Document
To delete a record, or document as it is called in MongoDB, we use the deleteOne()

method.
The first parameter of the deleteOne() method is a query object defining which
document to delete.
Note: If the query finds more than one document, only the first occurrence is deleted.
Example
Delete the document with the address "Mountain 21":
if (err) throw err;
var myquery = { address: 'Mountain 21' };
dbo.collection("customers").deleteOne(myquery, function(err, obj) {
if (err) throw err;
console.log("1 document deleted");
db.close();
});
Page 87 of 93
});
Delete Many
To delete more than one document, use the deleteMany() method.
The first parameter of the deleteMany() method is a query object defining which
documents to delete.
Example
Delete all documents were the address starts with the letter "O":
if (err) throw err;
var myquery = { address: /^O/ };
dbo.collection("customers").deleteMany(myquery, function(err, obj) {
if (err) throw err;
console.log(obj.result.n + " document(s) deleted");
db.close();
});
});
Node.js MongoDB Drop

Drop Collection
Page 88 of 93
You can delete a table, or collection as it is called in MongoDB, by using the drop()
method.
The drop() method takes a callback function containing the error object and the result
parameter which returns true if the collection was dropped successfully, otherwise it
returns false.
Example
Delete the "customers" table:
if (err) throw err;
dbo.collection("customers").drop(function(err, delOK) {
if (err) throw err;
if (delOK) console.log("Collection deleted");
db.close();
});
});
db.dropCollection
You can also use the dropCollection() method to delete a table (collection).
The dropCollection() method takes two parameters: the name of the collection and a
callback function.
Page 89 of 93
Example
Delete the "customers" collection, using dropCollection():
if (err) throw err;
dbo.dropCollection("customers", function(err, delOK) {
if (err) throw err;
if (delOK) console.log("Collection deleted");
db.close();
});
});
Node.js MongoDB Update

Update Document
You can update a record, or document as it is called in MongoDB, by using the

updateOne() method.
The first parameter of the updateOne() method is a query object defining which
document to update.
Note: If the query finds more than one record, only the first occurrence is updated.
The second parameter is an object defining the new values of the document.
Page 90 of 93
Example
Update the document with the address "Valley 345" to name="Mickey" and
address="Canyon 123":
var url = "mongodb://127.0.0.1:27017/";
if (err) throw err;
var myquery = { address: "Valley 345" };
var newvalues = { $set: {name: "Mickey", address: "Canyon 123" } };
dbo.collection("customers").updateOne(myquery, newvalues, function(err, res) {
if (err) throw err;
console.log("1 document updated");
db.close();
});
});
Update Only Specific Fields
When using the $set operator, only the specified fields are updated:
Example
Update the address from "Valley 345" to "Canyon 123":
Page 91 of 93
if (err) throw err;
var myquery = { address: "Valley 345" };
var newvalues = {$set: {address: "Canyon 123"} };
dbo.collection("customers").updateOne(myquery, newvalues, function(err, res) {
if (err) throw err;
console.log("1 document updated");
db.close();
});
});
Update Many Documents
To update all documents that meets the criteria of the query, use the updateMany()
method.
Example
Update all documents where the name starts with the letter "S":
var url = "mongodb://127.0.0.1:27017/";
Page 92 of 93
if (err) throw err;
var myquery = { address: /^S/ };
var newvalues = {$set: {name: "Minnie"} };
dbo.collection("customers").updateMany(myquery, newvalues, function(err, res) {
if (err) throw err;
console.log(res.result.nModified + " document(s) updated");
db.close();
});
});
EXERCISE:
1.Create Node.js Application to show all MongoDB operations.
EVALUATION:
Understanding /
Involvement Timely
Completion
(10)
(4) (3)
(3)
Page 93 of 93

5.AWP Labmanual New

Uploaded by

Copyright:

Available Formats

5.AWP Labmanual New

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

5.AWP Labmanual New

Uploaded by

Copyright:

Available Formats

Ahmedabad Institute of Technology

Computer Engineering Department

Advanced Web Programming(3161611)

Prepared By: - Prof. Darshana. H. Patel.

Sr. Page No.

3. Angular JS Forms and Validations

TITLE: Introduction to HTML,CSS,JavaScript,BootStap.

OBJECTIVES: On completion of this experiment students will be able to…

What You Can Do with Bootstrap

There are a lot more things you can do with Bootstrap.

Advantages of Using Bootstrap

Creating Your First Web Page with Bootstrap

Step 1: Creating a Basic HTML file

<meta name="viewport" content="width=device-width, initial-scale=1, shrink-

<title>Basic HTML File</title>

Step 2: Making this HTML File a Bootstrap Template

<meta name="viewport" content="width=device-width, initial-scale=1, shrink-

<title>Basic Bootstrap Template</title>

Step 3: Saving and Viewing the File

Now save the file on your desktop as "bootstrap-template.html".

1.Create Custom components using bootstrap

Signature with date: ________________

TITLE: Expressions in AngularJS

OBJECTIVES: On completion of this experiment students will be able to…

AngularJS is a JavaScript framework. It can be added to an HTML page with a <script>

AngularJS is a JavaScript framework written in JavaScript.

AngularJS Extends HTML

AngularJS extends HTML with ng-directives.

The ng-app directive defines an AngularJS application.

The ng-bind directive binds application data to the HTML view.

<p>Name: <input type="text" ng-model="name"></p>

AngularJS starts automatically when the web page has loaded.

AngularJS expressions can be written inside double braces: {{ expression }}.

AngularJS expressions can also be written inside a directive: ng-bind="expression".

<p>My first expression: {{ 5 + 5 }}</p>

1.Create Angular JS Application using expression

Signature with date: ________________

TITLE: Angular JS Forms and Validations.

OBJECTIVES: On completion of this experiment students will be able to…

Input controls are the HTML input elements:

Input controls provide data-binding by using the ng-model directive.

<input type="text" ng-model="firstname">

The application does now have a property named firstname.

The property firstname, can be referred to in a controller:

<div ng-app="myApp" ng-controller="formCtrl">

AngularJS can validate input data.

AngularJS offers client-side form validation.

<p>Try writing in the input field:</p>

<p>The input's valid state is:</p>

<p>Try writing in the input field:</p>

<p>The input's valid state is:</p>

1.Create student information form and apply validation

Signature with date: ________________

TITLE: Creating a single page website using AngularJS.

OBJECTIVES: On completion of this experiment students will be able to…

When to use SPA?