Advanced Web Programming Winter 2022 GTU Paper Solution | 3161611

function validateEmail(email) {
  // Regular expression pattern for email validation
  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  
  // Check if the email matches the pattern
  return emailPattern.test(email);
}

// Test the function
const email1 = "test@example.com";
console.log(validateEmail(email1)); // true

const email2 = "invalid.email";
console.log(validateEmail(email2)); // false

In the above code, we define a function called validateEmail that takes an email address as a parameter. We use a regular expression pattern (emailPattern) to define the format for a valid email address. The pattern ^[^\s@]+@[^\s@]+\.[^\s@]+$ checks that the email address has at least one character before the @ symbol, followed by at least one character before the dot (.), and at least one character after the dot.

The test method of the regular expression is used to check if the email matches the pattern. If it does, the function returns true, indicating a valid email address. Otherwise, it returns false.

A Single Page Application (SPA) is a web application that operates within a single HTML page. Instead of loading separate HTML pages for each interaction, the SPA dynamically updates the content on the same page, providing a smoother and more responsive user experience.

AngularJS is a popular JavaScript framework for building SPAs. It extends HTML with new attributes and provides a structured way to build dynamic web applications. Here are some advantages of using AngularJS:

1. Two-way Data Binding: AngularJS utilizes two-way data binding, which means that changes in the model (data) are automatically reflected in the view (UI), and vice versa. This simplifies the development process and reduces the amount of boilerplate code needed to keep the UI and data in sync.
2. Modular Architecture: AngularJS promotes a modular approach to application development. It allows developers to split their application into reusable components called directives, controllers, and services. This modularity enhances code maintainability, reusability, and testability.
3. Dependency Injection: AngularJS has a built-in dependency injection mechanism that helps manage dependencies between different components. It allows developers to easily inject required dependencies into components, making the code more modular and easier to test.
4. Templating and Directives: AngularJS provides a powerful templating system that allows developers to create dynamic views using HTML templates with added functionality. Directives extend HTML with custom tags and attributes, enabling the creation of reusable UI components and enhancing code readability.
5. Rich Set of Features: AngularJS offers a comprehensive set of features to support the development of complex web applications. These include data binding, form validation, routing, animation support, filters, internationalization, and more. These features help reduce the amount of custom code developers need to write and improve productivity.
6. Community and Ecosystem: AngularJS has a large and active community of developers, providing extensive resources, tutorials, and third-party libraries. This vibrant ecosystem makes it easier to find solutions to common problems and promotes continuous learning and improvement.
7. Seamless Integration: AngularJS can be easily integrated with other libraries and frameworks. It provides integration with popular libraries like jQuery and supports modular loading systems such as RequireJS. This flexibility allows developers to leverage existing code and tools while adopting AngularJS incrementally.

In AngularJS, data binding is a powerful feature that allows you to establish a connection between the application’s data and the UI elements, ensuring that any changes in the data are automatically reflected in the UI, and vice versa. There are three types of data binding in AngularJS:

1. One-way Data Binding ({{ expression }}): One-way data binding allows you to interpolate expressions and bind them to the HTML template. It updates the view (UI) whenever the data changes, but any changes in the view do not affect the data. This type of binding is denoted by the double curly braces ({{ }}) in the HTML template. For example:

<div>
  <h1>{{ message }}</h1>
</div>

In the above code, the message variable is bound to the <h1> element using one-way data binding. Whenever the value of message changes in the JavaScript code, the corresponding text in the UI will be automatically updated.

2. Model (Two-way) Data Binding (ng-model): Two-way data binding establishes a synchronization between the data and the UI. It allows changes in the UI to update the data, and changes in the data to update the UI automatically. The ng-model directive is used to achieve two-way data binding. For example:

<input type="text" ng-model="name">
<p>Hello, {{ name }}!</p>

In the above code, the ng-model directive binds the value of the input field to the name variable. As the user types in the input field, the name variable is updated automatically, and the corresponding message is displayed in the <p> element.

3. Event Data Binding (ng-click, ng-change, etc.): Event data binding allows you to bind functions to specific events in the UI. When the event is triggered, the associated function is executed, and you can access and manipulate the data within that function. AngularJS provides directives like ng-click and ng-change to bind functions to events. For example:

<button ng-click="incrementCounter()">Increment</button>
<p>Counter: {{ counter }}</p>

In AngularJS, a controller is a JavaScript constructor function that plays a crucial role in defining the behavior and data of a particular view or a section of a view. Controllers are responsible for managing the application’s state, handling user interactions, and exposing data to the view.

Here’s an example of a simple AngularJS controller:

angular.module('myApp', [])
  .controller('MyController', function() {
    var vm = this;
    vm.message = 'Hello, AngularJS!';
    
    vm.changeMessage = function() {
      vm.message = 'New message!';
    };
  });

In the above code, we define a controller called MyController using the controller() function provided by AngularJS. The second argument to the function is the constructor function for the controller.

Inside the controller, we create a variable vm and assign this to it. This is a common practice to maintain a reference to the controller’s scope, as this may change its context within nested functions.

We then define a property message on the controller’s scope (vm), which is set to the initial value of 'Hello, AngularJS!'. This property will be accessible in the view associated with this controller.

Additionally, we define a function changeMessage on the controller’s scope. This function changes the value of message to 'New message!' when invoked.

To use the controller in the HTML view, we add the ng-controller directive and specify the name of the controller:

<div ng-app="myApp" ng-controller="MyController as vm">
  <h1>{{ vm.message }}</h1>
  <button ng-click="vm.changeMessage()">Change Message</button>
</div>

To send an HTTP POST request in AngularJS, you can use the $http service provided by AngularJS. Here’s the syntax:

angular.module('myApp', [])
  .controller('MyController', function($http) {
    var vm = this;
    
    vm.sendData = function() {
      var data = {
        name: 'John Doe',
        email: 'johndoe@example.com'
      };
      
      $http.post('/api/endpoint', data)
        .then(function(response) {
          // Handle success
          console.log(response.data);
        })
        .catch(function(error) {
          // Handle error
          console.error(error);
        });
    };
  });

In the above code, we define a controller called MyController that injects the $http service as a dependency. Inside the controller, we create a function called sendData that will be triggered when you want to send the POST request.

Inside the sendData function, we define the data to be sent in the request payload. In this example, we have an object with a name and an email property.

We then use the $http.post() method to send the POST request to the specified endpoint (/api/endpoint) with the provided data. The .then() function is used to handle the success response, and the .catch() function is used to handle any errors that occur during the request.

Expressions in AngularJS and JavaScript have some similarities, but there are also key differences in their syntax and behavior.

AngularJS Expressions:

• Syntax: AngularJS expressions are enclosed in double curly braces ({{ expression }}).
• Context: AngularJS expressions are evaluated within the context of AngularJS. They have access to AngularJS-specific features such as built-in directives, filters, and services.
• Purpose: AngularJS expressions are primarily used for data binding, displaying dynamic values in the UI, and performing basic operations.
• Limitations: AngularJS expressions are limited in terms of what they can do compared to JavaScript. They cannot contain statements, loops, conditionals, or function declarations.

JavaScript Expressions:

• Syntax: JavaScript expressions can be written in various ways, depending on the context. They can be assigned to variables, used as function arguments, or evaluated within other JavaScript code blocks.
• Context: JavaScript expressions are evaluated within the JavaScript runtime environment, which provides access to the full range of JavaScript language features and APIs.
• Purpose: JavaScript expressions are used for general-purpose programming tasks. They can perform complex calculations, control program flow with conditionals and loops, define and invoke functions, and interact with the DOM and other APIs.
• Flexibility: JavaScript expressions offer more flexibility and power compared to AngularJS expressions. They can handle a wide range of programming tasks and can be used in various JavaScript environments, including server-side and client-side applications.

In AngularJS, $rootScope is a special object that serves as the root of the scope hierarchy. It is the parent scope for all other scopes in an AngularJS application. Unlike regular scopes, which are created for specific views or controllers, $rootScope is accessible across the entire application.

The $rootScope object is automatically created by AngularJS and is injected into the application’s run-time phase. It acts as a global scope that can be used to store and share data among different parts of the application.

To use $rootScope, you need to inject it as a dependency in your controller, service, or directive. Here’s an example:

angular.module('myApp', [])
  .controller('MyController', function($rootScope) {
    // Access and use $rootScope here
  });

Once you have access to $rootScope, you can use it like any other scope in AngularJS. You can assign values to properties, define functions, and bind data to the view.

Here’s an example of using $rootScope to share data between multiple controllers:

angular.module('myApp', [])
  .controller('ControllerA', function($rootScope) {
    $rootScope.sharedData = 'Hello from Controller A!';
  })
  .controller('ControllerB', function($rootScope) {
    // Access the shared data from Controller A
    console.log($rootScope.sharedData);
  });

In AngularJS, validations can be implemented using various techniques and features provided by the framework. Here are some common methods for implementing validations in AngularJS:

1. Form Validation: AngularJS provides built-in form validation directives that can be used to validate form inputs. These directives include ng-required, ng-minlength, ng-maxlength, ng-pattern, and more. By adding these directives to form fields, you can enforce specific validation rules and display validation messages to the user.

Example:

<form name="myForm">
  <input type="text" name="username" ng-model="user.username" ng-minlength="4" ng-maxlength="10" required>
  <div ng-show="myForm.username.$error.minlength || myForm.username.$error.maxlength">
    Username should be between 4 and 10 characters long.
  </div>
</form>

In the above code, the ng-minlength and ng-maxlength directives ensure that the username input field has a minimum length of 4 and a maximum length of 10 characters. The required directive makes the field mandatory. If the validation fails, the error message is displayed using the ng-show directive.

2. Custom Validation Directives: You can also create custom validation directives to implement complex validation logic that goes beyond the built-in directives. Custom directives allow you to define your own validation rules and behaviors. These directives can be attached to form fields and use a combination of the $validators and $parsers functions to perform the validation.

Example:

angular.module('myApp')
  .directive('customValidation', function() {
    return {
      require: 'ngModel',
      link: function(scope, element, attrs, ngModelCtrl) {
        ngModelCtrl.$validators.customValidation = function(modelValue, viewValue) {
          // Custom validation logic
          return /* true or false based on validation */;
        };
      }
    };
  });

In the above code, we define a custom validation directive called customValidation. The directive is applied to an input field, and the ngModelCtrl.$validators function is used to define the validation logic. The custom validation function should return true if the value is valid and false otherwise.

3. Form Controller and Scope Properties: AngularJS provides a form controller and its associated properties to manage form validation. The form controller keeps track of the form’s validation status and provides properties such as $valid, $invalid, $dirty, $pristine, and more. These properties can be used to conditionally display validation messages or enable/disable form submission buttons.

Example:

<form name="myForm">
  <input type="text" name="username" ng-model="user.username" required>
  <div ng-show="myForm.username.$dirty && myForm.username.$invalid">
    Username is required.
  </div>
  <button type="submit" ng-disabled="myForm.$invalid">Submit</button>
</form>

In the above code, the ng-show directive displays the validation message only when the username field is dirty (user has interacted with it) and invalid. The ng-disabled directive disables the submit button if the form is invalid.

<!DOCTYPE html>
<html ng-app="myApp">
<head>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.8.2/angular.min.js"></script>
</head>
<body>
  <div ng-controller="NumberController">
    <input type="number" ng-model="inputNumber" placeholder="Enter a number">
    <button ng-click="checkOddOrEven()">Check</button>
    <p ng-if="result !== null">
      The number {{ inputNumber }} is <strong>{{ result }}</strong>.
    </p>
  </div>

  <script>
    angular.module('myApp', [])
      .controller('NumberController', function($scope) {
        $scope.checkOddOrEven = function() {
          if ($scope.inputNumber % 2 === 0) {
            $scope.result = 'even';
          } else {
            $scope.result = 'odd';
          }
        };
      });
  </script>
</body>
</html>

In the above code, we define an AngularJS module called myApp and a controller called NumberController. The controller has a function called checkOddOrEven that is triggered when the “Check” button is clicked.

Inside the checkOddOrEven function, we use the modulus operator (%) to check if the input number is divisible by 2. If the remainder is 0, we set the $scope.result variable to 'even'; otherwise, we set it to 'odd'.

The result is displayed in the view using the ng-if directive. The <p> element is conditionally rendered based on whether the result variable is null or not. If it’s not null, the message is displayed, showing the input number and whether it’s odd or even.

In Node.js, streams are a fundamental concept used for handling data flow. Streams allow you to read or write data in a continuous and asynchronous manner, making it efficient for working with large datasets or handling real-time data.

Streams in Node.js can be categorized into four types based on the direction of data flow and how they interact with the underlying source or destination:

1. Readable Streams: Readable streams are used for reading data from a source. They provide an interface for consuming data in a chunk-by-chunk manner. Examples of readable streams include reading data from a file, receiving data from an HTTP request, or reading data from a database query result.
2. Writable Streams: Writable streams are used for writing data to a destination. They provide an interface for sending data in chunks. Examples of writable streams include writing data to a file, sending data in an HTTP response, or writing data to a database.
3. Duplex Streams: Duplex streams represent streams that can both read and write data. They provide a two-way communication channel. Duplex streams are bidirectional and allow data to flow in both directions simultaneously. Examples of duplex streams include network sockets and piping data between processes.
4. Transform Streams: Transform streams are a special type of duplex stream that allow for data transformation while it’s being read or written. They take input, perform some transformation on it, and provide the transformed output. Transform streams are commonly used for tasks such as data compression, encryption, or data parsing. Examples include the zlib module for compression and the crypto module for encryption.

Node.js is an open-source, cross-platform, server-side runtime environment built on Chrome’s V8 JavaScript engine. It allows developers to build scalable, high-performance, and event-driven applications using JavaScript.

Here are some key features of Node.js:

1. Asynchronous and Event-Driven: Node.js uses an event-driven, non-blocking I/O model, which makes it efficient and scalable for handling real-time applications. This approach allows Node.js to handle a large number of concurrent connections with low overhead.
2. Lightweight and Fast: Node.js is built on Chrome’s V8 JavaScript engine, which compiles and executes JavaScript code at lightning-fast speeds. It also has a small footprint, making it lightweight and easy to deploy.
3. Cross-Platform: Node.js runs on multiple platforms, including Windows, macOS, and Linux, making it a versatile choice for developers.
4. NPM: Node.js comes with a powerful package manager called NPM (Node Package Manager), which provides access to a vast collection of open-source packages and modules that can be easily installed and used in Node.js applications.
5. Single Threaded, But Highly Scalable: Although Node.js runs on a single thread, it uses an event-driven, non-blocking I/O model, which allows it to handle a large number of concurrent connections efficiently.
6. No Buffering: Node.js streams data as soon as it’s available, without buffering it in memory, making it memory-efficient and fast.
7. Support for Web Sockets: Node.js has built-in support for Web Sockets, which allows for real-time, bidirectional communication between the client and server.

Node.js provides a set of core modules that are included with the Node.js installation. These core modules offer essential functionality for building applications. Some of the core modules in Node.js are:

1. fs: This module provides file system-related operations such as reading and writing files, creating directories, and manipulating file metadata.
2. http: The http module enables creating HTTP servers and making HTTP requests. It provides classes and methods for handling HTTP-related functionality, including creating web servers, handling incoming requests, and sending HTTP requests to other servers.
3. path: The path module handles file paths and directory paths. It provides methods for resolving, joining, and normalizing file and directory paths across different platforms.
4. os: This module provides operating system-related information, such as the platform, hostname, network interfaces, and more. It offers methods to access and retrieve information about the underlying operating system.
5. util: The util module provides utility functions and helpful methods for working with JavaScript objects. It includes functions for object inspection, type checking, and formatting strings.
6. events: The events module allows the creation and handling of custom events. It provides an event emitter pattern where objects can emit events and register event listeners to respond to those events.
7. stream: The stream module offers an API for working with streaming data. It provides base classes and methods for creating and manipulating readable, writable, duplex, and transform streams.
8. crypto: The crypto module provides cryptographic functionality. It includes methods for hashing, encryption, decryption, signing, and verifying data using various algorithms.
9. querystring: This module handles URL query strings by providing methods for parsing and formatting query strings.
10. url: The url module facilitates URL parsing, formatting, and resolution. It offers methods for working with URLs, including parsing URL components, formatting URLs, and resolving relative URLs.

To create a simple server in Node.js that returns “Hello World” as the response, you can use the http module to create an HTTP server and handle incoming requests. Here’s an example:

const http = require('http');

// Create the HTTP server
const server = http.createServer((req, res) => {
  // Set the response headers
  res.writeHead(200, { 'Content-Type': 'text/plain' });

  // Write the response body
  res.write('Hello World');

  // End the response
  res.end();
});

// Start the server
const port = 3000;
server.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

In the above code, we first require the http module, which is a core module in Node.js. We then create an HTTP server using the createServer method. The server takes a callback function that will be invoked for each incoming request.

Inside the callback function, we set the response headers using res.writeHead() method. In this example, we set the status code to 200 (OK) and the Content-Type to 'text/plain'.

Next, we write the response body using res.write(). In this case, we write the string 'Hello World'.

Finally, we end the response using res.end(), which signals to the server that we have finished writing the response.

To start the server, we specify a port number (in this example, 3000) and call the listen method on the server instance. We also log a message to the console to indicate that the server is listening on the specified port.

REPL stands for “Read-Eval-Print Loop”. It is an interactive programming environment available in many programming languages, including Node.js. The purpose of a REPL is to provide an environment where you can type code, have it executed, and see the results immediately.

In a REPL, you can type individual lines or blocks of code, and the environment will read the code, evaluate it, execute it, and print the result back to you. This allows you to experiment with code, test small snippets, and quickly iterate without the need to write a complete program or compile code.

Here are some key features and purposes of a REPL:

1. Read: The REPL reads the code you enter and parses it for execution.
2. Eval: The parsed code is evaluated, meaning it is executed and processed by the language runtime or interpreter.
3. Print: The result of the evaluated code is printed or displayed back to you. This can include the output of the code, the return value of a function, or an error message.
4. Loop: After displaying the result, the REPL loops back to the read stage, allowing you to enter more code for evaluation. This creates an interactive and iterative development process.

The REPL environment is commonly used for:

• Quick code testing: You can try out code snippets or experiment with language features to see how they work.
• Debugging: You can use the REPL to investigate and debug code by executing individual statements and inspecting values.
• Learning and exploration: The interactive nature of a REPL makes it a useful tool for learning a language or exploring its features.
• Prototyping: You can rapidly prototype and iterate on code without the need to write and execute a complete program.

To perform insert and find operations on a student database using Node.js and MongoDB, you need to have the MongoDB Node.js driver installed and a MongoDB database set up. Here’s an example code that demonstrates the basic steps:

1. Install the MongoDB Node.js driver using npm:

npm install mongodb

2. Connect to the MongoDB database:

const { MongoClient } = require('mongodb');

// Connection URL
const url = 'mongodb://localhost:27017';

// Database Name
const dbName = 'mydatabase';

// Create a new MongoClient
const client = new MongoClient(url);

// Connect to the MongoDB server
client.connect(function(err) {
  if (err) {
    console.error('Error connecting to the database:', err);
    return;
  }

  console.log('Connected successfully to the database');

  // Specify the database
  const db = client.db(dbName);

  // Perform operations
  insertStudent(db);
  findStudents(db);

  // Close the connection
  client.close();
});

3. Insert a student into the database:

function insertStudent(db) {
  // Get the collection
  const collection = db.collection('students');

  // Create a student document
  const student = { name: 'John Doe', age: 20, major: 'Computer Science' };

  // Insert the student document
  collection.insertOne(student, function(err, result) {
    if (err) {
      console.error('Error inserting student:', err);
      return;
    }

    console.log('Student inserted successfully');
  });
}

4. Find all students in the database:

function findStudents(db) {
  // Get the collection
  const collection = db.collection('students');

  // Find all students
  collection.find({}).toArray(function(err, students) {
    if (err) {
      console.error('Error finding students:', err);
      return;
    }

    console.log('Students found:', students);
  });
}

In this example, we first connect to the MongoDB database using the MongoDB Node.js driver. Once connected, we specify the database name and perform the insert and find operations.

The insertStudent function inserts a student document into the “students” collection using the insertOne method. The findStudents function retrieves all the documents from the “students” collection using the find method and converts the result to an array using toArray.

In Node.js, an error-first callback is a convention used to handle errors in asynchronous operations. It is a callback function that takes two parameters: the first parameter is reserved for an error object (if any), and the second parameter is for the result or data.

The error-first callback pattern ensures consistent handling of errors in asynchronous operations, making it easier for developers to handle both success and error scenarios. Here’s an example of an error-first callback:

function getData(callback) {
  // Simulating an asynchronous operation
  setTimeout(() => {
    const error = null; // No error in this example
    const data = { id: 1, name: 'John Doe' };

    // Call the callback function
    callback(error, data);
  }, 1000);
}

// Usage of the error-first callback
getData((err, result) => {
  if (err) {
    console.error('An error occurred:', err);
  } else {
    console.log('Data retrieved successfully:', result);
  }
});

In this example, the getData function simulates an asynchronous operation, such as making a database query or an API request. After a certain delay (simulated by setTimeout), it calls the callback function with the appropriate parameters.

If an error occurs during the asynchronous operation, the error object is passed as the first parameter to the callback. If there is no error, the first parameter is set to null or undefined, and the result or data is passed as the second parameter.

In the callback function, you can check the value of the err parameter to determine if an error occurred. If it is non-null, you can handle the error case appropriately. If err is null, you can assume the operation was successful and process the result or data.

To perform update and delete operations on an Employee database using Node.js and MongoDB, you need to have the MongoDB Node.js driver installed and a MongoDB database set up. Here’s an example code that demonstrates the basic steps:

1. Install the MongoDB Node.js driver using npm:

npm install mongodb

2. Connect to the MongoDB database:

const { MongoClient, ObjectID } = require('mongodb');

// Connection URL
const url = 'mongodb://localhost:27017';

// Database Name
const dbName = 'mydatabase';

// Create a new MongoClient
const client = new MongoClient(url);

// Connect to the MongoDB server
client.connect(function(err) {
  if (err) {
    console.error('Error connecting to the database:', err);
    return;
  }

  console.log('Connected successfully to the database');

  // Specify the database
  const db = client.db(dbName);

  // Perform operations
  updateEmployee(db);
  deleteEmployee(db);

  // Close the connection
  client.close();
});

3. Update an employee in the database:

function updateEmployee(db) {
  // Get the collection
  const collection = db.collection('employees');

  // Specify the employee to update
  const filter = { _id: new ObjectID('employee_id_here') };
  const update = { $set: { salary: 5000 } };

  // Update the employee document
  collection.updateOne(filter, update, function(err, result) {
    if (err) {
      console.error('Error updating employee:', err);
      return;
    }

    console.log('Employee updated successfully');
  });
}

4. Delete an employee from the database:

function deleteEmployee(db) {
  // Get the collection
  const collection = db.collection('employees');

  // Specify the employee to delete
  const filter = { _id: new ObjectID('employee_id_here') };

  // Delete the employee document
  collection.deleteOne(filter, function(err, result) {
    if (err) {
      console.error('Error deleting employee:', err);
      return;
    }

    console.log('Employee deleted successfully');
  });
}

In this example, we first connect to the MongoDB database using the MongoDB Node.js driver. Once connected, we specify the database name and perform the update and delete operations.

The updateEmployee function updates an employee document in the “employees” collection using the updateOne method. It specifies the filter to identify the employee to update (by _id in this case) and the update operation to perform (in this case, setting the salary to a new value).

The deleteEmployee function deletes an employee document from the “employees” collection using the deleteOne method. It specifies the filter to identify the employee to delete (by _id in this case).

Remember to replace the MongoDB connection URL, database name, and collection name with your own values. Additionally, replace the employee_id_here placeholder with the actual _id of the employee you want to update or delete.