AWP manual

Ahmedabad Institute of Technology
Information Technology Department
Advanced Web Programming (3161611)
Laboratory Manual
Year: 2024-2025
NAME
ENROLLMENT NO
BATCH
YEAR
Subject Faculty: Head of Department

Prof. Vanita Dandhwani Dr.Ashish Chaurasiya(HOD IT
Ahmedabad Institute of Technology
IT Department
CERTIFICATE
This is to certify that Mr. / Ms._______________________________________________ of

Enrolment No______________________ has Satisfactorily completed the
course in__________________________________ as by the Gujarat Technological
University for______________ Year (B.E.) semester ____________of Information
Technology in the Academic year______________________.
Date of Submission:-__________________________
Prof. Margi Patel Dr. Ashish Chaurasiya

(Head Of Department)
Signature: ___________________________
Page 2 of 67
DEPARTMENT OF INFORMATION TECHNOLOGY
VISION
“To impart quality education and research in Information Technology to produce a
competent, committed and goal oriented workforce to fulfill the needs of the local and
global IT Industry.”
Mission of the Department

The Department‘s Mission is to advance knowledge in the field of Information
Technology and Allied Science by providing our students with the highest quality
educational experience towards
M1: Producing quality workforce with cutting edge technology.
M2: Engaging in innovative teaching, learning, research and community service.
M3: Inculcating sense of ethical attitude, social responsibility and developing leadership
quality required for a responsible IT professional.
Page 3 of 67
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 4 of 67
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 5 of 67
● 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 6 of 67
</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>
<script
src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/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.
Page 7 of 67
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
EVALUATION:
Understanding / Timely
Involvement (4) Total (10)
Problem solving (3) Completion (3)
Signature with date: ________________
Page 8 of 67
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
<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.
Page 9 of 67
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.
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:
Page 10 of 67
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>
<script>
Page 11 of 67
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>
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
Page 12 of 67
<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>
EXERCISE:
1.Create student information form and apply validation
EVALUATION:
Page 13 of 67
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.
● 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
Page 14 of 67
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
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=
Page 15 of 67
"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">
<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
Page 16 of 67
.when('/', {
templateUrl : 'first.html',
controller : 'FirstController'
})
.when('/second', {
templateUrl : 'second.html',
controller : 'SecondController'
})
.when('/third', {
templateUrl : 'third.html',
controller : 'ThirdController'
})
.otherwise({redirectTo: '/'});
});


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:
Page 17 of 67
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
What is a Node.js File?
Page 18 of 67
● 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
crypto To handle OpenSSL cryptographic functions
dgram Provides implementation of UDP datagram sockets
dns To do DNS lookups and name resolution functions
Page 19 of 67
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
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
Page 20 of 67
util To access utility functions
v8 To access information about V8 (the JavaScript engine)
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.
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:
Page 21 of 67
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:
Page 22 of 67
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");
// 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");
Page 23 of 67
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
● 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
Page 24 of 67
r+:Open file for reading and writing. An exception occurs if the file does not
2
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 25 of 67
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!");
});
$ 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)
Page 26 of 67
Parameters
● path − This is the string having file name including path.

arguments (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.
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.
Page 27 of 67
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
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 28 of 67
$ 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)
}
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'
Page 29 of 67
● 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 −
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
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.
Page 30 of 67
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
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());
}
});
});
$ node main.js
Verify the Output.
Page 31 of 67
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.
● 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 32 of 67
// 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.
--------------------------------------------------------------------------------------------------------
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.
callback.
Page 33 of 67
Example
if (err) {
}
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) {
}
// Close the opened file.

fs.close(fd, function(err) {
if (err) {
console.log(err);
}
console.log("File closed successfully.");
});
});
});
});
$ node main.js
Page 34 of 67
Verify the Output.
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
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.
callback.
Example
console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
if (err) {
}
console.log("File deleted successfully!");
});
$ 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)
Page 35 of 67
Parameters
● path − This is the directory name including path.
● mode − This is the directory permission to be set. Defaults to
0777.
callback.
Example
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
arguments (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");
Page 36 of 67
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
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
callback.
Example
console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err) {
if (err) {
}
console.log("Going to read directory /tmp");
Page 37 of 67
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
EXERCISE:
1.Create Node.js Application to show all File operations.
EVALUATION:
Page 38 of 67
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 39 of 67
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 40 of 67
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 41 of 67
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 42 of 67
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 43 of 67
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 44 of 67
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
Page 45 of 67
Emitted when an error occurs. The 'close' event will be called directly
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 46 of 67
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 47 of 67
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 48 of 67
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 49 of 67
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 50 of 67
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() {
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:
Page 51 of 67
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() {
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:
Page 52 of 67
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 −
● 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.
Page 53 of 67
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;
// 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();
});
}).listen(8081);
// Console will print the message
Page 54 of 67
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/
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;
});
response.on('end', function() {
Page 55 of 67
// 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!
</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:
Page 56 of 67
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();
});
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;
Page 57 of 67
console.log("Collection created!");
db.close();
});
});
EXERCISE:
1.Create Node.js Application to Connect Node JS with MongoDB
EVALUATION:
Page 58 of 67
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) {
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:
Page 59 of 67
if (err) throw err;
var myobj = [
{ name: 'John', address: 'Highway 71'},
{ 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();
});
});
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'}
Page 60 of 67
];
dbo.collection("products").insertMany(myobj, function(err, res) {
if (err) throw err;
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);
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;
Page 61 of 67
dbo.collection("customers").find({}).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
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.
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();
Page 62 of 67
});
});
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":
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;
var mysort = { name: 1 };
dbo.collection("customers").find().sort(mysort).toArray(function(err, result) {
if (err) throw err;
db.close();
});
});
Sort Descending
Page 63 of 67
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();
});
});
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();
});
});
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":
Page 64 of 67
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
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.
Example
Delete the "customers" collection, using dropCollection():
Page 65 of 67
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.
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":
if (err) throw err;
Page 66 of 67
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/";

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:
Page 67 of 67

AWP manual

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

AWP manual

Uploaded by

Document Information

Original Description:

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

AWP manual

Uploaded by

Copyright:

Available Formats

Ahmedabad Institute of Technology

Information Technology Department

Advanced Web Programming (3161611)

Subject Faculty: Head of Department

This is to certify that Mr. / Ms._______________________________________________ of

Prof. Margi Patel Dr. Ashish Chaurasiya

Mission of the Department

Sr. Page No.

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

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

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".

Example {{ 5 + 5 }} or {{ firstName + " " + lastName }}

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.

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

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

Signature with date: ________________

TITLE: Creating a single page website using AngularJS.

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

Signature with date: ________________

TITLE: Node JS Concept.

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

● Node.js is an open source server environment

Here is how PHP or ASP handles a file request:

1. Sends the task to the computer's file system.

Here is how Node.js handles a file request:

1. Sends the task to the computer's file system.

Node.js runs single-threaded, non-blocking, asynchronously programming, which is very

What Can Node.js Do?

● Node.js can generate dynamic page content

What is a Node.js File?

Consider modules to be the same as JavaScript libraries.

A set of functions you want to include in your application.

Here is a list of the built-in modules of Node.js version 6.10.3:

assert Provides a set of assertion tests