➢ Compatibility with JavaScript: TypeScript is a superset of JavaScript, which means

MEAN STACK UNIT-04

that it is fully compatible with existing JavaScript code. This makes it easy to gradually
adopt TypeScript in existing projects or libraries.
TYPESCRIPT ➢ Strong Community: TypeScript has a large and active community of developers and
contributors, which means that there is a lot of documentation, tools, and libraries
TypeScript: available. This can help developers get started with TypeScript quickly and find
solutions to common problems.
TypeScript is an open-source programming language developed and maintained by
Microsoft. It is a statically typed superset of JavaScript that adds optional static typing and Overall, TypeScript can help developers write better quality code, catch errors earlier, and
other features to the language. TypeScript code is transpiled into JavaScript code that can be more productive, which can lead to better software development outcomes.
run on any browser or JavaScript engine.
Installing TypeScript:
TypeScript was designed to help developers write more scalable and maintainable
applications by adding features like type checking, interfaces, classes, and modules. It also To install TypeScript, follow these steps:
provides improved IDE support and better tooling for large codebases.
Install Node.js: TypeScript is built on top of Node.js, so you need to install it first. You can
TypeScript can be used for both frontend and backend development, and is often used with download and install Node.js from the official website: https://nodejs.org/
popular frameworks like React, Angular, and Node.js. It can also be used for writing
serverless functions and mobile applications using frameworks like React Native. Install TypeScript using npm: Once Node.js is installed, you can install TypeScript using npm
(Node Package Manager). Open a terminal or command prompt and run the following
TypeScript is compatible with existing JavaScript code, and developers can gradually adopt command:
it in their projects. It can also be used in combination with other languages like Rust, C#, and
Python through WebAssembly. npm install -g typescript

Why TypeScript: This will install TypeScript globally on your system.

TypeScript offers several benefits over regular JavaScript: Verify the installation: To verify that TypeScript is installed correctly, open a terminal or
command prompt and run the following command:
➢ Type Safety: TypeScript is a statically typed language, which means that it provides
type checking during development. This can help catch errors earlier in the tsc -v
development process, before they cause runtime errors.
This should display the version number of TypeScript that you just installed.
➢ Improved Code Quality: TypeScript allows developers to write more maintainable
and scalable code, as it provides features like classes, interfaces, and modules. This That's it! You have now installed TypeScript on your system and you are ready to start using
makes it easier to organize code, reuse code, and collaborate with other developers. it.
➢ Better IDE Support: TypeScript provides better tooling and IDE support than regular
JavaScript. This includes features like code completion, navigation, and refactoring. Basics of TypeScript:
This can help developers be more productive and write code faster.
Here are some basics of TypeScript:
Variables and Types: In TypeScript, you can declare variables using the let keyword. You can In this example, we have defined a class Person with a name and age property, as well as a
also specify the type of the variable using a colon followed by the type. For example: greet method that prints a message to the console. We have also created a new object john
of type Person.
let message: string = "Hello, TypeScript!";
Interfaces: TypeScript supports interfaces, which allow you to define a set of properties and
In this example, we have declared a variable message of type string. methods that a class must implement. For example:

Functions: You can define functions in TypeScript using the function keyword. You can also interface Animal {
specify the types of the parameters and the return type. For example:
name: string;
function add(a: number, b: number): number {
age: number;
return a + b;
makeSound(): void;
}
}
In this example, we have defined a function add that takes two parameters of type number
and returns a value of type number. class Dog implements Animal {

Classes: TypeScript supports classes, which allows you to define a blueprint for creating constructor(public name: string, public age: number) {}
objects. You can use the class keyword to define a class, and the constructor method to
initialize the object. For example: makeSound() {

class Person { console.log("Woof!");

constructor(public name: string, public age: number) {} }

greet() { }

console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`); let myDog = new Dog("Buddy", 5);

} myDog.makeSound();

} In this example, we have defined an interface Animal that has a name, age, and makeSound
method. We have also defined a class Dog that implements the Animal interface, and
let john = new Person("John", 30); created a new object myDog of type Dog.

john.greet(); These are just some of the basics of TypeScript. TypeScript also supports advanced features
like generics, decorators, and namespaces, among others.
Functions: console.log("Hello, world!");

Functions in TypeScript are similar to functions in JavaScript, but with added features to }
support static typing and other language features. Here are some key aspects of functions in
}
TypeScript:
In this example, we have defined a function greet that takes an optional parameter name of
Function Declaration: In TypeScript, you can declare a function using the function keyword,
type string. If name is provided, it will print a personalized greeting, otherwise it will print a
followed by the function name, parameter list, and return type (if any). For example:
generic greeting.
function add(a: number, b: number): number {
➢ Default Parameters: TypeScript allows you to declare default values for parameters
return a + b; by using the equal sign. For example:

} function greet(name: string = "world") {

In this example, we have defined a function named add that takes two parameters of type console.log(`Hello, ${name}!`);
number and returns a value of type number.
}
➢ Function Expression: You can also define a function using a function expression,
In this example, we have defined a function greet that takes a parameter name of type
which assigns the function to a variable. For example:
string with a default value of "world". If name is not provided, it will use the default value.
let add = function(a: number, b: number): number {
➢ Rest Parameters: TypeScript allows you to define rest parameters by prefixing the
return a + b; last parameter with an ellipsis. Rest parameters allow you to pass an arbitrary
number of arguments to a function. For example:
}
function multiply(factor: number, ...numbers: number[]): number {
In this example, we have defined a function expression that assigns a function to the
variable add. return numbers.reduce((a, b) => a * b, factor);

➢ Optional Parameters: TypeScript allows you to declare optional parameters by }

adding a question mark after the parameter name. For example:
In this example, we have defined a function multiply that takes a factor parameter of type
function greet(name?: string) { number and a rest parameter numbers of type number[]. It multiplies all the numbers in the
numbers array and returns the result multiplied by the factor.
if (name) {
These are just some of the features of functions in TypeScript. TypeScript also supports
console.log(`Hello, ${name}!`); function overloading, arrow functions, and other advanced features.

} else {
Parameter Types and Return Types: ➢ Optional Parameters: You can specify an optional function parameter by adding a
question mark after the parameter name, and then specifying a default value if the
In TypeScript, you can specify the types of function parameters and the return type of the parameter is not provided. For example:
function. This allows the TypeScript compiler to check the type safety of your code and
provide helpful error messages if there is a type mismatch. Here's how you can specify function greet(name?: string): void {
parameter types and return types in TypeScript:
if (name) {
➢ Parameter Types: You can specify the type of a function parameter by using a colon
console.log(`Hello, ${name}!`);
followed by the type name. For example:
} else {
function add(a: number, b: number): number {
console.log("Hello, world!");
return a + b;
}
}
}
In this example, we have specified that the a and b parameters are of type number.
In this example, we have specified that the name parameter is optional by using the ?
➢ Return Type: You can specify the return type of a function by adding a colon followed
symbol. If the name parameter is not provided, the function will use the default value of
by the type name after the parameter list. For example:
undefined.
function add(a: number, b: number): number {
➢ Union Types: You can specify that a parameter can have multiple types by using a
return a + b; union type. For example:

} function display(value: string | number): void {

In this example, we have specified that the function returns a value of type number. console.log(value);

➢ Void Type: If a function does not return a value, you can specify the return type as }
void. For example:
In this example, we have specified that the value parameter can be of type string or
function log(message: string): void { number.

console.log(message); These are just some of the ways you can specify parameter types and return types in
TypeScript. By using type annotations in your functions, you can make your code more
} readable and maintainable, and catch potential errors at compile time.

In this example, we have specified that the log function does not return a value by using the Arrow Function:
void keyword as the return type.
Arrow functions in TypeScript are a shorthand way of writing function expressions. They are Here's an example of a function type in TypeScript:
similar to regular functions, but with a more concise syntax. Here's how you can define an
arrow function in TypeScript: type AddFunction = (a: number, b: number) => number;

const add = (a: number, b: number): number => { In this example, we have defined a function type called AddFunction that takes two
parameters a and b, both of type number, and returns a value of type number.
return a + b;
We can use this function type to define a variable that can hold a function that matches the
}; type:

In this example, we have defined an arrow function called add that takes two parameters a const add: AddFunction = (a, b) => {
and b, both of which are of type number. The function returns the sum of a and b, which is
also of type number. return a + b;

The arrow function is defined using the following syntax: };

(parameters) => expression In this example, we have defined a variable called add of type AddFunction. We have
assigned an arrow function to this variable that matches the function type.
The parameters are enclosed in parentheses and separated by commas, and the expression
is the code that the function will execute. The expression can be a single line of code, like in Function types can also include optional and rest parameters:
our example, or it can be a block of code enclosed in curly braces.
type GreetingFunction = (name?: string, ...args: string[]) => void;
You can also omit the curly braces and the return keyword if the function has only one
In this example, we have defined a function type called GreetingFunction that takes an
statement:
optional parameter name of type string and a rest parameter args of type string[]. The
const square = (x: number): number => x * x; function has a return type of void.

In this example, we have defined an arrow function called square that takes a parameter x We can use this function type to define a variable that can hold a function that matches the
of type number. The function returns the square of x, which is also of type number. type:

Arrow functions can be very useful when you need to define small, one-off functions that const greet: GreetingFunction = (name, ...args) => {
don't require a name or a separate function declaration. They can also make your code
if (name) {
more readable by reducing the amount of boilerplate code needed for function definitions.
console.log(`Hello, ${name}!`);
Function Types:
} else {
In TypeScript, functions are first-class citizens and can have types just like any other values.
Function types describe the type of a function, including its parameter types and return console.log("Hello, world!");
type.
 } console.log("Hello, stranger!");

if (args.length > 0) { }

console.log("Additional arguments:"); }

args.forEach(arg => console.log(arg)); In this example, the name parameter is marked as optional by adding ? after the parameter
name. This means that the parameter may or may not be provided when calling the
} function. If the parameter is provided, its value will be used in the greeting message. If it is
not provided, the greeting message will use the default value of "stranger".
};
Default Parameters:
In this example, we have defined a variable called greet of type GreetingFunction. We have
assigned an arrow function to this variable that matches the function type. To define a default value for a parameter, we can simply assign a value to the parameter in
the function signature. Here's an example:
Function types are very useful when you want to define functions with specific signatures,
and ensure that only functions that match the type are assigned to a variable or passed as function add(a: number, b: number = 0): number {
an argument. They can help catch type errors at compile time and make your code more
robust. return a + b;

Optional and Default Parameters: }

In TypeScript, function parameters can be marked as optional or have default values. In this example, the b parameter is given a default value of 0 by assigning it in the function
Optional parameters are parameters that may or may not be provided when calling a signature. This means that if the b parameter is not provided when calling the function, its
function, while default parameters are parameters that have a default value that is used if default value of 0 will be used. If the b parameter is provided, its value will be used in the
the parameter is not provided. addition operation.

Optional Parameters: It's important to note that optional parameters must come after required parameters in the
function signature, and default parameters must come after all required and optional
To make a parameter optional, we can use the ? operator after the parameter name in the parameters.
function signature. Here's an example:
Rest Parameter:
function greet(name?: string) {
In TypeScript, you can define a function that accepts a variable number of arguments using
if (name) { a rest parameter. A rest parameter is denoted by the ellipsis ... followed by the parameter
name and it allows a function to accept any number of arguments.
console.log(`Hello, ${name}!`);
Here's an example of a function that uses a rest parameter:
} else {
 function multiply(multiplier: number, ...numbers: number[]): number { interface Person {

return numbers.reduce((acc, val) => acc * val, multiplier); name: string;

} age: number;

In this example, the multiply function takes a required parameter multiplier of type number greet: () => void;
and a rest parameter numbers of type number[]. The rest parameter allows the function to
accept any number of additional arguments, which are collected into an array called }
numbers.
In this example, we've defined an interface called Person that requires an object to have a
The function then uses the reduce method to multiply all the numbers in the numbers array name property of type string, an age property of type number, and a greet method that
together, starting with the multiplier value. takes no arguments and returns no value.

Here's an example of calling the multiply function: Once an interface is defined, we can use it to define the shape of objects that conform to
that interface. Here's an example of creating an object that conforms to the Person
const result = multiply(2, 3, 4, 5); interface:

console.log(result); // Output: 120 const person: Person = {

In this example, we are calling the multiply function with the multiplier value of 2 and three name: "Alice",
additional arguments 3, 4, and 5. The multiply function collects these arguments into the
numbers array and multiplies them together with the reduce method, resulting in the value age: 30,
of 120.
greet: () => console.log("Hello!")
Rest parameters can be very useful when you need to accept an unknown number of
};
arguments in a function, such as when working with arrays or lists of data.
In this example, we've created an object called person that has a name property of type
Creating an Interface: string, an age property of type number, and a greet method that takes no arguments and
returns no value. This object conforms to the Person interface, so we've declared its type as
In TypeScript, an interface is a way to define a contract or a blueprint for an object. It
Person.
defines the properties and methods that an object must have to be considered an instance
of that interface. Interfaces can also be extended to create new interfaces that inherit properties and
methods from other interfaces. Here's an example of extending the Person interface to
To create an interface in TypeScript, we use the interface keyword followed by the name of
create a new Employee interface:
the interface and the properties and methods it should contain. Here's an example:
 interface Employee extends Person { const cat = {

jobTitle: string; name: "Fluffy",

salary: number; speak: () => console.log("Meow!")

} };

In this example, we've extended the Person interface to create a new interface called greet(cat); // Output: "Hello, Fluffy!" followed by "Meow!"
Employee that requires an object to have all the properties and methods of the Person
interface, as well as a jobTitle property of type string and a salary property of type number. In this example, we've defined an interface called Animal that requires an object to have a
name property of type string and a speak method that takes no arguments and returns no
Duck Typing: value.

Duck typing is a type system used in some programming languages, including TypeScript. In We've then defined a greet function that takes an object of type Animal and logs a greeting
duck typing, the type of an object is determined by its behavior, rather than its class or type message using the object's name property and speak method.
hierarchy. If an object quacks like a duck and walks like a duck, it's considered to be a duck,
Finally, we've created an object called cat that has a name property of type string and a
even if it's not an instance of a Duck class or interface.
speak method that takes no arguments and logs "Meow!" to the console.
In TypeScript, duck typing is used to determine the compatibility of an object with an
Even though cat is not explicitly declared as an instance of the Animal interface, it has all
interface. If an object has all the properties and methods required by an interface, it's
the properties and methods required by that interface. Therefore, when we call the greet
considered to be an instance of that interface, even if it's not explicitly declared as such.
function with the cat object as an argument, it behaves as if it were an instance of the
Here's an example of duck typing in TypeScript: Animal interface.

interface Animal { This is an example of duck typing in action, where an object's compatibility with an interface
is determined by its behavior, rather than its type or class hierarchy.
name: string;
Function Types:
speak: () => void;
In TypeScript, we can define the types of functions using function types. Function types
} describe the types of a function's parameters and return value. They can be used to specify
the types of function parameters when declaring a function or when defining a function
function greet(animal: Animal) {
type for a variable or property.
console.log(`Hello, ${animal.name}!`);
Here's an example of a function type:
animal.speak();
type AddFunction = (a: number, b: number) => number;
}
In this example, we've defined a type called AddFunction that describes a function that Function types are a powerful feature of TypeScript that allow us to specify the types of
takes two parameters of type number and returns a value of type number. functions in a concise and expressive way. They can be used to define the types of function
parameters, return values, and even function variables and properties.
We can use this function type to declare a variable that points to a function that satisfies
this type: Extending Interfaces:
const add: AddFunction = (a, b) => a + b; In TypeScript, we can create new interfaces by extending existing ones using the extends
keyword. This allows us to create more specific interfaces that inherit properties and
In this example, we've declared a variable called add that has the type AddFunction. We've
methods from a more general interface.
also assigned it an arrow function that takes two parameters of type number and returns
their sum. Here's an example of how to extend an interface:

We can also use function types as parameters in other functions. Here's an example: interface Animal {

function applyOperation(a: number, b: number, op: (x: number, y: number) => number): name: string;
number {
age: number;
return op(a, b);
speak: () => void;
}
}
const result = applyOperation(4, 2, (x, y) => x * y);
interface Dog extends Animal {
console.log(result); // Output: 8
breed: string;
In this example, we've defined a function called applyOperation that takes two parameters
of type number and a third parameter of type (x: number, y: number) => number, which is a }
function type that describes a function that takes two parameters of type number and
const myDog: Dog = {
returns a value of type number.
name: "Buddy",

age: 3,
The applyOperation function calls the function passed as the op parameter with the two a
and b parameters, and returns its result. breed: "Golden Retriever",

We've then called the applyOperation function with 4, 2, and an arrow function that speak: () => console.log("Woof!")
multiplies its two parameters. The result of the function call is 8, which is logged to the
console. };
In this example, we've defined an interface called Animal that has three properties: name of console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
type string, age of type number, and speak of type () => void.
}
We've then defined a new interface called Dog that extends the Animal interface using the
extends keyword. The Dog interface has all the properties of the Animal interface, plus an }
additional property breed of type string.
const person = new Person("John", 30);
Finally, we've declared a variable called myDog that has the type Dog. We've assigned it an
person.sayHello(); // Output: Hello, my name is John and I'm 30 years old.
object that has all the properties required by the Dog interface, as well as the speak
method. In this example, we've defined a class called Person with two properties: name of type
string and age of type number. We've also defined a constructor method that takes two
By extending interfaces, we can create new interfaces that inherit properties and methods
parameters, name and age, and assigns their values to the corresponding properties.
from existing ones, making it easier to define complex types with reusable code. We can
also use interface extension to define more specific types that share common properties We've then defined a sayHello method that logs a message to the console using the name
and methods, which helps us to write more modular and maintainable code. and age properties.

Classes: We've created an instance of the Person class using the new keyword, passing in the name
and age parameters to the constructor. We've then called the sayHello method on the
In TypeScript, classes are a way to define objects with properties and methods. Classes person object, which logs a message to the console.
provide a blueprint for creating objects, and allow us to define the properties and methods
that those objects will have. Classes in TypeScript can also inherit from other classes using the extends keyword. This
allows us to define more specific classes that inherit properties and methods from a more
Here's an example of a simple class: general class.
class Person { Here's an example of a class that inherits from another class:

name: string; class Student extends Person {

age: number; studentId: number;

constructor(name: string, age: number) { constructor(name: string, age: number, studentId: number) {
this.name = name; super(name, age);

this.age = age; this.studentId = studentId;

} }
sayHello() { study() {
 console.log(`${this.name} is studying with student ID ${this.studentId}.`); constructor(name: string, age: number) {

} this.name = name;

} this.age = age;

const student = new Student("Jane", 20, 12345); }

student.sayHello(); // Output: Hello, my name is Jane and I'm 20 years old. }

student.study(); // Output: Jane is studying with student ID 12345. In this example, we've defined a class called Person with two properties: name of type
string and age of type number. We've also defined a constructor method that takes two
In this example, we've defined a class called Student that extends the Person class using the parameters, name and age, and assigns their values to the corresponding properties using
extends keyword. The Student class has an additional property studentId of type number, the this keyword.
and a study method that logs a message to the console using the name and studentId
properties. We can create an instance of the Person class by using the new keyword and passing in the
name and age parameters to the constructor:
We've created an instance of the Student class using the new keyword, passing in the name,
age, and studentId parameters to the constructor. We've then called the sayHello and study const person = new Person("John", 30);
methods on the student object, which logs messages to the console.
In this example, we've created a new object called person from the Person class, passing in
Constructor: the values "John" and 30 for the name and age parameters, respectively.

In TypeScript, the constructor is a special method that is used to create and initialize objects We can also use default parameter values in the constructor:
created from a class. It is executed automatically when an object is instantiated from a
class Person {
class.
name: string;
The constructor method has the same name as the class and can accept zero or more
parameters. It is defined using the constructor keyword followed by parentheses that age: number;
contain the parameter list and the method body.
constructor(name = "Unknown", age = 0) {
Here's an example of a constructor method in TypeScript:
this.name = name;
class Person {
this.age = age;
name: string;
}
age: number;
}
In this example, we've set default values for the name and age parameters in the Example:
constructor. If no values are passed in when creating an instance of the Person class, the
default values of "Unknown" and 0 will be used for name and age, respectively. class Person {

The constructor method can also include access modifiers such as public, private, and private name: string;
protected to control the visibility of the class properties.
constructor(name: string) {
Access Modifiers: this.name = name;

In TypeScript, access modifiers are used to control the visibility and accessibility of class }
members (properties and methods) from outside the class. There are three access modifiers
in TypeScript: public, private, and protected. greet() {

➢ public modifier: Members declared as public are accessible from anywhere, both console.log(`Hello, my name is ${this.name}!`);
inside and outside the class. This is the default access modifier if none is specified.
}
Example:
}
class Person {
let person = new Person('John');
public name: string;
console.log(person.name); // Error: 'name' is private
constructor(name: string) {
person.greet(); // Output: Hello, my name is John!
this.name = name;
In this example, name property of the Person class is declared as private. We can't access it
} outside the class using the person.name statement. But we can access it within the class
using the this.name statement.
}
➢ protected modifier: Members declared as protected are accessible within the class
let person = new Person('John'); and its subclasses. They are not accessible from outside the class hierarchy.

console.log(person.name); // Output: John Example:

In this example, name property of the Person class is declared as public. We can access it class Person {
outside the class using the person.name statement.
protected name: string;
➢ private modifier: Members declared as private are only accessible within the class.
They are not accessible from outside the class, not even from derived classes. constructor(name: string) {
 this.name = name; Properties are variables that belong to an instance of a class, and methods are functions
that belong to a class.
}
Here's an example of how to create properties and methods in TypeScript:
}
class Person {
class Employee extends Person {
name: string;
private department: string;
age: number;
constructor(name: string, department: string) {
constructor(name: string, age: number) {
super(name);
this.name = name;
this.department = department;
this.age = age;
}
}
public getDetails() {
greet(): void {
console.log(`Name: ${this.name}, Department: ${this.department}`);
console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
}
}
}
}
let emp = new Employee('John', 'Sales');
let person = new Person('John', 30);
console.log(emp.name); // Error: 'name' is protected
person.greet(); // Output: Hello, my name is John and I'm 30 years old.
emp.getDetails(); // Output: Name: John, Department: Sales
In this example, the Person class has two properties: name and age. The constructor
In this example, name property of the Person class is declared as protected. We can't access function is used to set the values of these properties when a new instance of the class is
it outside the class hierarchy using the emp.name statement. But we can access it within created.
the Employee class (subclass of Person class) using the this.name statement.
The greet method is a function that belongs to the Person class. It can be called on an
Properties and Methods: instance of the class using the person.greet() statement. This method uses the this keyword
to refer to the instance of the class and access its properties.
Properties and methods are two important features of classes in TypeScript.
Note that by default, properties in TypeScript are public, which means they can be accessed console.log(person.age); // Error: 'age' is protected
from outside the class.
In this example, the name property is declared as private, which means it can only be
You can also specify the access modifier for a property using the public, private, or accessed within the Person class. The age property is declared as protected, which means it
protected keyword. For example: can be accessed within the Person class and its subclasses.

class Person { The getName and getAge methods are used to get the values of the name and age
properties, respectively. These methods can be called on an instance of the Person class,
private name: string; but the name and age properties cannot be accessed directly from outside the class.
protected age: number;
Creating & Using Namespaces:
constructor(name: string, age: number) {
In TypeScript, a namespace is a way to group related code together and prevent naming
this.name = name; collisions. Namespaces are similar to modules, but while modules are used to organize code
that will be compiled to separate files, namespaces are used to organize code within a
this.age = age; single file.

} To create a namespace in TypeScript, you can use the namespace keyword followed by the
namespace name and the code that should be included in the namespace. Here's an
getName(): string { example:
return this.name; namespace MyNamespace {
} export interface Person {
getAge(): number { name: string;
return this.age; age: number;
} }
} export function greet(person: Person): void {
let person = new Person('John', 30); console.log(`Hello, my name is ${person.name} and I'm ${person.age} years old.`);
console.log(person.getName()); // Output: John }
console.log(person.getAge()); // Output: 30 }
console.log(person.name); // Error: 'name' is private
let person: MyNamespace.Person = { name: 'John', age: 30 }; console.log(`Hello, my name is ${person.name} and I'm ${person.age} years old.`);

MyNamespace.greet(person); // Output: Hello, my name is John and I'm 30 years old. }

In this example, we've created a namespace called MyNamespace. Inside the namespace, In this example, we've created a module that exports an interface called Person and a
we've defined an interface called Person and a function called greet that takes a Person function called greet.
object as a parameter and logs a greeting to the console.
To use the Person interface and the greet function in another module or in your application
Note that we've used the export keyword to make the Person interface and the greet code, you can use the import statement. Here's an example:
function available outside the namespace.
import { Person, greet } from './my-module';
To use the Person interface and the greet function, we can refer to them using the
namespace name followed by a dot notation, like MyNamespace.Person and let person: Person = { name: 'John', age: 30 };
MyNamespace.greet.
greet(person); // Output: Hello, my name is John and I'm 30 years old.
Using namespaces can help avoid naming collisions, especially when working with large
In this example, we've imported the Person interface and the greet function from the my-
projects that have many modules and components. However, it's important to use them
module.ts file using the import statement. We can then use these exported variables and
judiciously and avoid creating deeply nested namespaces, as this can make the code harder
functions as if they were defined in our own code.
to read and maintain.
Note that we've used the file path './my-module' as the import specifier to indicate the
Creating and using Modules: location of the module. This path is relative to the file that is importing the module.

In TypeScript, modules are used to organize code into reusable, self-contained units of You can also export classes and other constructs from a module in TypeScript. To export a
functionality. Each module can have its own private variables and functions, which are not class, you can use the export keyword before the class definition. To import a class from a
accessible from outside the module, as well as public variables and functions that can be module, you can use the import statement with the same syntax as for variables and
used by other modules. functions.

To create a module in TypeScript, you can use the export keyword to export variables and export class Greeter {
functions that you want to make available outside the module. Here's an example:
constructor(private message: string) {}
export interface Person {
greet(name: string): void {
name: string;
console.log(`${this.message}, ${name}!`);
age: number;
}
}
}
export function greet(person: Person): void {
 import { Greeter } from './greeter'; function to import them. This format is well-suited for web applications, as it supports
asynchronous loading and allows for modular code organization.
let greeter = new Greeter('Hello');
Module Loaders
greeter.greet('John'); // Output: Hello, John!
Node.js
In this example, we've defined a Greeter class in a module and exported it using the export
keyword. We can then import the Greeter class in another module and use it to create Node.js is a popular server-side platform that uses the CommonJS module format and the
instances of the Greeter class. Node.js module loader to load modules at runtime. Node.js provides a built-in require
function that allows you to load modules from the local file system or from third-party
Module Formats and Loaders: packages installed via npm.

When working with modules in TypeScript, you have several options for the module format Webpack
and the module loader that you can use to load and execute your modules.
Webpack is a popular module bundler that can be used to package your TypeScript modules
Module formats specify the syntax used to define and import modules in your code, while into a single JavaScript file that can be loaded in the browser. Webpack supports multiple
module loaders specify how modules are loaded and executed at runtime. Here are some of module formats and can handle dependencies between modules, making it a powerful tool
the most common module formats and loaders used in TypeScript: for building complex web applications.

Module Formats SystemJS

CommonJS SystemJS is a dynamic module loader that can load modules in multiple formats, including
CommonJS, AMD, and ES modules. SystemJS allows you to load modules at runtime, which
The CommonJS module format is used in Node.js and allows you to define modules using
can be useful for applications that need to dynamically load modules based on user
the module.exports and require statements. This format is well-suited for server-side
interactions or other runtime conditions.
development, but may not be the best choice for web applications due to its synchronous
loading behavior. In summary, when working with TypeScript modules, you have several options for the
module format and loader that you can use. The choice of format and loader will depend on
ES modules
the requirements of your application and the platforms on which it will be deployed.
ES modules are the standard module format for JavaScript, and are supported by modern
Module Vs Namespace:
browsers and Node.js. ES modules use the import and export statements to define and
import modules. This format allows for more fine-grained control over dependencies and In TypeScript, both modules and namespaces serve as a way to organize code and
supports asynchronous loading, making it a good choice for web applications. encapsulate functionality, but they are not interchangeable and have different use cases.
AMD Modules

Asynchronous Module Definition (AMD) is a module format used by RequireJS and other
AMD loaders. AMD modules use the define function to define modules, and the require
Modules in TypeScript are used to define and organize code in separate files, and to Generics in TypeScript allow you to write reusable code that can work with different types
manage dependencies between different parts of an application. A module can export of data. Generics provide a way to define functions, classes, and interfaces that can operate
variables, functions, classes, and other entities that can be consumed by other modules. on a range of types, without knowing the specific type at compile-time.

Modules in TypeScript support various module formats, such as CommonJS, AMD, and ES6 In TypeScript, generics are represented by type parameters, which are placeholders for
modules, and can be loaded using module loaders such as Node.js, Webpack, and SystemJS. specific types. Type parameters are declared using angle brackets < >, and can be used to
define the type of function parameters, return types, and class properties.
Namespaces
Here's an example of a simple generic function in TypeScript that takes an array of any type
Namespaces in TypeScript are used to group related code and avoid naming conflicts. A and returns the first element of the array:
namespace can contain variables, functions, classes, and interfaces, and can be nested to
create a hierarchical organization of code. function getFirst<T>(arr: T[]): T {

Unlike modules, namespaces do not have a separate file scope, and all entities in a return arr[0];
namespace are in the same global scope. This can sometimes lead to naming conflicts if
multiple namespaces define entities with the same name. }

Namespaces in TypeScript are similar to namespaces in other languages such as C# and let arr1 = [1, 2, 3];
Java, and can be useful for organizing large codebases into logical units.
let arr2 = ["a", "b", "c"];
When to use Modules vs Namespaces
console.log(getFirst<number>(arr1)); // output: 1
In general, you should use modules in TypeScript to organize code across different files and
console.log(getFirst<string>(arr2)); // output: "a"
manage dependencies between different parts of an application. Modules allow you to
easily reuse and share code, and provide a clear separation of concerns between different In this example, the getFirst function takes an array of type T and returns the first element
parts of an application. of that array, which is also of type T. The <T> syntax in the function signature declares the
type parameter T, which can be any type.
Namespaces, on the other hand, are best used to organize related code within a single file
or a small set of files. Namespaces can be useful for avoiding naming conflicts, but should When calling the function, we specify the type of T using angle brackets. In the first call, we
be used sparingly to avoid cluttering the global namespace. specify T as number, and in the second call, we specify T as string.

In summary, while both modules and namespaces are useful for organizing code in Generics can also be used to define classes and interfaces. Here's an example of a generic
TypeScript, they have different use cases and should be used appropriately depending on class that represents a stack of elements of any type:
the requirements of your application.
class Stack<T> {
What is Generics:
private items: T[] = [];
 push(item: T) { In TypeScript, type parameters are a feature that allows you to create generic types,
functions, and classes that can work with different types of data, without knowing the
this.items.push(item); specific type at compile-time. Type parameters act as placeholders for the actual types that
will be used when the code is executed.
}
Type parameters are declared using angle brackets < > and can be used to define the type
pop(): T | undefined {
of function parameters, return types, and class properties. For example, consider the
return this.items.pop(); following generic function that swaps two elements of an array:

} function swap<T>(arr: T[], i: number, j: number): void {

} const temp = arr[i];

let stack1 = new Stack<number>(); arr[i] = arr[j];

stack1.push(1); arr[j] = temp;

stack1.push(2); }

console.log(stack1.pop()); // output: 2 In this function, T is a type parameter that represents the type of elements in the array.
When calling the function, you specify the actual type of T, such as number or string.
let stack2 = new Stack<string>();
const arr1: number[] = [1, 2, 3];
stack2.push("a");
swap<number>(arr1, 0, 2); // swaps the first and third elements of the array
stack2.push("b");
Type parameters can also be used to define generic classes. For example, consider the
console.log(stack2.pop()); // output: "b" following Stack class that can hold elements of any type:

In this example, the Stack class is defined as a generic class with a type parameter T. The class Stack<T> {
class contains two methods, push and pop, which operate on elements of type T. When
creating an instance of the Stack class, we specify the type of T using angle brackets, just private items: T[] = [];
like we did with the getFirst function.
push(item: T) {
Generics provide a powerful way to write reusable code in TypeScript, and are used
this.items.push(item);
extensively in many popular libraries and frameworks, such as Angular and React.
}
What are Type Parameters:
pop(): T | undefined {
 return this.items.pop(); function getLast<T>(arr: T[]): T | undefined {

} return arr[arr.length - 1];

} }

In this class, T is a type parameter that represents the type of elements in the stack. When In this function, T is a type parameter that represents the type of elements in the array.
creating an instance of the Stack class, you specify the actual type of T, such as number or When the function is called, the type parameter is replaced with an actual type, such as
string. number or string.

const stack1 = new Stack<number>(); Here's an example of how you can call the getLast function with different types of arrays:

stack1.push(1); const numbers = [1, 2, 3];

stack1.push(2); const lastNumber = getLast(numbers); // inferred type: number | undefined

console.log(stack1.pop()); // prints 2 const strings = ["hello", "world"];

const stack2 = new Stack<string>(); const lastString = getLast(strings); // inferred type: string | undefined

stack2.push("hello"); const empty = [];

stack2.push("world"); const lastEmpty = getLast(empty); // inferred type: undefined

console.log(stack2.pop()); // prints "world" Note that the inferred type of the return value depends on the type of the array passed as
an argument. In this example, the return type is either the type of the elements in the array
Type parameters provide a powerful way to write generic code in TypeScript, making it or undefined if the array is empty.
more flexible and reusable.
You can also explicitly specify the type parameter when calling the function:
Generic Functions:
const lastNumber = getLast<number>(numbers); // explicitly specify the type parameter
In TypeScript, you can create generic functions using type parameters. Generic functions
allow you to write code that works with different types of data without having to specify Generic functions provide a powerful way to write reusable code in TypeScript that can
the type upfront. work with different types of data.

Here's an example of a generic function that takes an array of values of any type and Generic Constraints:
returns the last element of the array:
In TypeScript, you can use generic constraints to restrict the types that can be used as type
parameters in generic functions or classes. A generic constraint allows you to specify that a
type parameter must extend a particular type or set of types.
Here's an example of a generic function that uses a generic constraint to restrict the types Generic constraints provide a powerful way to write more type-safe and reusable code in
of its input: TypeScript by ensuring that the types used as type parameters meet certain requirements.

interface HasLength {
MONGO DB
length: number;
Mongo DB:
}
MongoDB is a popular open-source NoSQL database that uses a document-oriented data
function getFirst<T extends HasLength>(arr: T): T extends any[] ? T[number] : T { model instead of the traditional relational data model used by SQL databases. MongoDB
stores data in flexible, semi-structured JSON-like documents, which can have fields that vary
return arr[0]; from document to document. This makes it easy to store and retrieve complex,
unstructured data, such as social media posts, user comments, and product catalogs.
}
MongoDB is designed to be highly scalable, fault-tolerant, and easy to use. It provides high-
In this function, the generic type parameter T is constrained to be a type that implements
performance, real-time data access, and can handle large volumes of data with ease.
the HasLength interface. The HasLength interface requires that any implementing type must
MongoDB also offers a range of advanced features, such as support for distributed
have a length property of type number.
databases, automatic sharding, and full-text search, that make it a popular choice for
The return type of the getFirst function uses a conditional type to determine whether the modern web and mobile applications.
input array is an array of some type or not. If it is, the function returns the type of the
elements of the array, otherwise it returns the original type T. Why Mongo DB:

Here's an example of how you can call the getFirst function with different types of input: There are several reasons why MongoDB is a popular choice for modern web and mobile
applications:
const numbers = [1, 2, 3];
1. Flexible data model: MongoDB's document-oriented data model allows you to store data
const firstNumber = getFirst(numbers); // inferred type: number in a flexible, semi-structured format, making it easy to store and retrieve complex,
unstructured data, such as social media posts, user comments, and product catalogs.
const strings = ["hello", "world"];
2. Scalability and performance: MongoDB is designed to be highly scalable and can handle
const firstString = getFirst(strings); // inferred type: string large volumes of data with ease. It also provides high-performance, real-time data access,
making it ideal for applications that require fast data retrieval.
const obj = { length: 5 };
3. Easy to use: MongoDB has a user-friendly interface, and its query language is similar to
const firstObj = getFirst(obj); // inferred type: { length: number }
JavaScript, making it easy for developers to learn and use.
Note that the inferred type of the return value depends on the type of the input passed as
an argument. In this example, the return type is either the type of the elements in the array
or the original type T.
4. No need for a separate ORM: Because MongoDB uses a document-oriented data model, This knowledge will serve as a foundation for further learning in MongoDB and building
there is no need for a separate Object-Relational Mapping (ORM) layer, which can simplify applications with this popular NoSQL database.
development and reduce complexity.
Document Database Overview:
5. Distributed database: MongoDB supports distributed databases, allowing you to easily
scale out your application across multiple servers or data centers. MongoDB is a document-oriented NoSQL database, which means it stores data as semi-
structured JSON-like documents instead of tables with rows and columns like in traditional
6. Open source: MongoDB is open source software, which means it is free to use and can be relational databases. Here are some key aspects of MongoDB's document database:
modified and distributed by anyone.
1. Documents: In MongoDB, data is stored as documents, which are similar to rows in a
Overall, MongoDB's flexibility, scalability, performance, ease of use, and open-source traditional database table but with a more flexible structure. Each document can have a
nature make it an attractive option for many modern web and mobile applications. different structure, and you can store nested objects and arrays within documents.

Introduction Module Overview: 2. Collections: Documents are organized into collections, which are similar to tables in a
traditional database. Collections can contain any number of documents, and each
The Introduction module for MongoDB covers the basics of MongoDB, including its document can have a different structure.
features, data model, installation, and setup. Here's a brief overview of what you can expect
to learn in this module: 3. Dynamic Schema: MongoDB has a dynamic schema, which means that you don't need to
define a fixed schema before inserting data. You can insert documents with different
1. Introduction to MongoDB: You will learn what MongoDB is, its features, and how it structures and fields at any time.
differs from traditional relational databases.
4. Indexing: MongoDB supports various types of indexes, which can improve query
2. MongoDB Data Model: You will learn about MongoDB's document-oriented data model, performance and optimize data retrieval. Indexes can be created on any field within a
including how data is organized and stored in collections and documents. document, including fields within nested objects and arrays.

3. Installation and Setup: You will learn how to install and set up MongoDB on your local 5. Querying: MongoDB provides a powerful query language that allows you to retrieve data
machine, including configuring the database server and connecting to the MongoDB shell. from collections based on specific criteria. You can use a wide range of operators and
functions to filter, sort, and aggregate data.
4. CRUD Operations: You will learn how to perform basic CRUD (Create, Read, Update,
Delete) operations in MongoDB, including inserting documents, querying data, and 6. Aggregation: MongoDB's aggregation framework provides a powerful way to analyze and
updating and deleting documents. manipulate data within collections. It allows you to group, filter, and transform data using a
pipeline of stages.
5. Indexing: You will learn how to create indexes in MongoDB to improve query
performance and optimize data retrieval. Overall, MongoDB's document database provides a flexible and scalable way to store and
retrieve data, making it an ideal choice for modern web and mobile applications. By using a
By the end of the Introduction module, you will have a solid understanding of MongoDB's
document-oriented data model, MongoDB allows you to store and access complex,
data model, how to install and set up MongoDB on your local machine, and how to perform
unstructured data with ease, and provides powerful query and aggregation capabilities to
basic CRUD operations and indexing in MongoDB.
help you analyze and manipulate your data.
Understanding JSON: The query language uses a syntax that is similar to JSON, with key-value pairs and operators.
For example, to retrieve all documents with an age greater than 30, you could use the
MongoDB stores data in the form of JSON-like documents, which means that data is following query:
represented in a semi-structured format that is similar to JSON. Here's how JSON is used in
MongoDB: db.users.find({ age: { $gt: 30 } })

Data Format: MongoDB stores data in documents, which are similar to JSON objects. Each Indexing: MongoDB supports various types of indexes that can improve query performance
document is represented as a set of key-value pairs, with field names and values separated and optimize data retrieval. Indexes can be created on any field within a document,
by a colon. For example, a document in MongoDB could look like this: including fields within nested objects and arrays.

{ Overall, MongoDB's use of JSON-like documents makes it easy to store and access data in a
flexible and scalable way. By using a document-oriented data model, MongoDB allows you
"_id": ObjectId("60b4a6f786ec6b00516d7f1a"), to store and access complex, unstructured data with ease, and provides powerful query and
indexing capabilities to help you retrieve and analyze your data.
"name": "John Smith",
MongoDB Structure and Architecture:
"age": 35,
MongoDB Structure
"email": "john.smith@example.com",
1. Database: A MongoDB database is a container for collections. Each database has a
"address": {
unique name and can contain any number of collections.
"street": "123 Main St",
2. Collection: A collection is a group of MongoDB documents. Collections are similar to
"city": "Anytown", tables in a traditional relational database. Collections can contain any number of
documents, and each document can have a different structure.
"state": "CA",
3. Document: A document is a set of key-value pairs that represent a record in a collection.
"zip": "12345" Documents are similar to rows in a table in a traditional relational database. MongoDB
documents are composed of fields, which can include sub-documents and arrays.
}
4. Field: A field is a key-value pair within a document. Fields are similar to columns in a table
}
in a traditional relational database. Fields can contain a variety of data types, including
Dynamic Schema: MongoDB has a dynamic schema, which means that you can insert strings, numbers, booleans, dates, and more.
documents with different structures and fields at any time. This flexibility allows you to
5. Index: A MongoDB index is a data structure that improves the speed of queries on a
store and access data without having to define a fixed schema beforehand.
collection. Indexes can be created on any field within a document, including fields within
Querying: MongoDB provides a powerful query language that allows you to retrieve data nested objects and arrays. MongoDB supports various types of indexes, including single
from documents based on specific criteria. field, compound, and text indexes.
6. GridFS: MongoDB provides a protocol for storing and retrieving large files, called GridFS. 7. Balancer: The balancer is responsible for balancing the distribution of data across shards
GridFS is useful when you need to store files that exceed the BSON document size limit of in a sharded cluster. The balancer runs as a background process and periodically checks the
16MB. distribution of data across shards, moving chunks of data as necessary to maintain a
balanced distribution.
Overall, MongoDB's structure is designed to be flexible, scalable, and document-oriented.
By using a document-oriented data model, MongoDB allows you to store and access 8. Backup and Recovery: MongoDB provides built-in tools for backup and recovery,
complex, unstructured data with ease, and provides powerful query and indexing including hot backups, point-in-time recovery, and backup validation.
capabilities to help you retrieve and analyze your data.
Overall, MongoDB's architecture is designed to be flexible, scalable, and distributed. By
Mongo DB Architecture using a cluster of servers, replica sets, and sharding, MongoDB can handle large volumes of
data and provide high availability and data redundancy. By using Memory Mapped Files
1. Cluster: MongoDB's architecture is designed to be highly scalable and distributed. It is (MMAP) and WiredTiger as storage engines, MongoDB provides high-performance storage
typically deployed as a cluster of servers, where each server is a node in the cluster. Each options that can be tailored to specific use cases. The query router and balancer enable
node can store a portion of the data, and the cluster as a whole can handle large volumes of MongoDB to efficiently handle queries across a distributed environment, while built-in
data with ease. backup and recovery tools ensure data availability and durability.

2. Replica Set: A replica set is a group of MongoDB servers that work together to provide
MongoDB Remote Management:
high availability and data redundancy. Each replica set contains a primary node and one or
more secondary nodes. The primary node handles all write operations, while the secondary MongoDB provides several options for remote management of its database instances. Here
nodes replicate the data from the primary node and can take over if the primary node fails. are some of the most common options:

3. Sharding: MongoDB supports sharding, which is a way to horizontally partition data 1. MongoDB Atlas: MongoDB Atlas is a fully managed cloud database service that provides
across multiple servers or shards. Sharding allows you to distribute data across multiple a GUI-based interface for managing MongoDB clusters in the cloud. It offers automatic
servers, which can improve query performance and handle large volumes of data. scaling, backup and recovery, and built-in security features such as encryption and
monitoring.
4. Memory Mapped Files (MMAP): MongoDB uses Memory Mapped Files (MMAP) for data
storage. This allows MongoDB to use the operating system's virtual memory system for 2. MongoDB Cloud Manager: MongoDB Cloud Manager is a web-based management
caching frequently accessed data, which can improve performance. service that provides automation and monitoring features for MongoDB deployments. It
supports both on-premise and cloud-based MongoDB deployments.
5. WiredTiger: MongoDB also supports WiredTiger as a storage engine. WiredTiger is a high-
performance, compressed, and scalable storage engine that supports multi-threaded access 3. Ops Manager: Ops Manager is a comprehensive management platform for MongoDB
to data. that provides automation, monitoring, and backup and recovery features. It is designed for
enterprise-level MongoDB deployments and supports on-premise and cloud-based
6. Query Router: The query router is responsible for directing queries to the appropriate
deployments.
shard in a sharded cluster. The query router acts as a proxy between clients and the shard
servers. 4. Third-party management tools: There are several third-party management tools
available for MongoDB, such as Studio 3T, Robo 3T, and NoSQLBooster.
These tools provide GUI-based interfaces for managing MongoDB databases and offer ➢ Verify that MongoDB is running by opening another command prompt and running
features such as data modeling, query visualization, and performance optimization. the following command:

Overall, MongoDB provides several options for remote management of its database Mongo
instances, ranging from fully managed cloud services to comprehensive on-premise
solutions. These tools offer automation, monitoring, backup and recovery, and security This should open the MongoDB shell.
features that can help you manage your MongoDB databases more effectively.
That's it! You should now have MongoDB up and running on your local computer.
Installing MongoDB on the local computer (Mac or Windows): Installing MongoDB on Mac
Installing MongoDB on Windows ➢ Go to the MongoDB downloads page at https://www.mongodb.com/download-
center/community and click on the "Download" button for the Community Server
➢ Go to the MongoDB downloads page at https://www.mongodb.com/download-
version.
center/community and click on the "Download" button for the Community Server
➢ Open the downloaded file and drag the MongoDB icon to the Applications folder.
version.
➢ Open a terminal window and create a directory where MongoDB will store its data.
➢ Open the downloaded file and follow the installation wizard. Make sure to select the
For example, you can use the following command:
"Complete" installation option.
➢ During the installation process, you will be prompted to choose a directory where mkdir -p /data/db
MongoDB will be installed. You can accept the default or choose a custom directory.
➢ After the installation is complete, open a command prompt and create a directory ➢ Set the appropriate permissions for the data directory by running the following
where MongoDB will store its data. For example, you can use the following command:
command:
sudo chown -R `id -un` /data/db
mkdir C:\data\db
➢ Start the MongoDB server by running the following command:
➢ Add the MongoDB binaries to your system's PATH environment variable by following
these steps: Mongod
• Open the Control Panel and go to System and Security > System > Advanced system
➢ Verify that MongoDB is running by opening another terminal window and running the
settings > Environment Variables.
following command:
• Under "System variables", find the "Path" variable and click "Edit".
• Add the path to the MongoDB binaries to the end of the "Variable value" field, Mongo
separated by a semicolon. For example: C:\Program Files\MongoDB\Server\4.4\bin
➢ Start the MongoDB server by opening a command prompt and running the following ➢ This should open the MongoDB shell.
command:
This is how installing Mongo DB in Windows & MAC OS’s.
Mongod
Introduction to MongoDB Cloud:
MongoDB Cloud is a suite of cloud-based services offered by MongoDB, Inc. that enables 1. Sign up for MongoDB Atlas: Go to the MongoDB Atlas website
developers to deploy, manage, and scale their MongoDB database instances in the cloud. (https://www.mongodb.com/cloud/atlas) and sign up for a new account or log in to your
MongoDB Cloud includes several services that provide different levels of functionality and existing account.
management capabilities:
2. Create a new project: Once you're logged in, create a new project by clicking the "New
1. MongoDB Atlas: MongoDB Atlas is a fully managed cloud database service that provides Project" button. Give your project a name and click "Create Project".
a GUI-based interface for managing MongoDB clusters in the cloud. It offers automatic
scaling, backup and recovery, and built-in security features such as encryption and 3. Create a new cluster: Within your project, click the "Build a Cluster" button. This will
monitoring. bring you to the cluster creation page.

2. Realm: Realm is a mobile application development platform that provides data 4. Choose a cloud provider and region: Choose your cloud provider and region where you
synchronization and backend services for mobile and web applications. It includes a fully want your cluster to be deployed. You can choose from AWS, Google Cloud, or Azure.
managed version of MongoDB Atlas and provides features such as user authentication, data
5. Choose a cluster tier: Select the cluster tier that meets your needs. MongoDB Atlas offers
access control, and serverless functions.
a range of cluster tiers, from a free tier suitable for development and testing to large-scale
3. Charts: Charts is a data visualization service that enables developers to create interactive clusters for production workloads.
charts and graphs from their MongoDB data. It includes a wide range of chart types and
6. Configure your cluster settings: Configure your cluster settings such as the number of
customization options, and can be embedded in web applications or shared via URLs.
nodes, disk size, backup options, and more. You can also choose to enable features such as
4. Cloud Manager: Cloud Manager is a web-based management service that provides encryption and network peering.
automation and monitoring features for MongoDB deployments. It supports both on-
7. Deploy your cluster: After you've configured your settings, click "Create Cluster" to
premise and cloud-based MongoDB deployments.
deploy your new MongoDB Atlas cluster.
5. Ops Manager: Ops Manager is a comprehensive management platform for MongoDB
8. Wait for your cluster to deploy: MongoDB Atlas will create your new cluster in the
that provides automation, monitoring, and backup and recovery features. It is designed for
background. This process can take a few minutes to complete. You can track the progress of
enterprise-level MongoDB deployments and supports on-premise and cloud-based
your deployment on the "Clusters" page in your MongoDB Atlas dashboard.
deployments.
Once your cluster is deployed, you can connect to it using the connection string provided by
Overall, MongoDB Cloud provides developers with a range of cloud-based services that
MongoDB Atlas. You can also manage your cluster, configure security settings, set up
make it easier to deploy, manage, and scale their MongoDB database instances. These
monitoring and alerts, and more, all from your MongoDB Atlas dashboard.
services provide features such as automatic scaling, backup and recovery, security, data
synchronization, and data visualization, and can help developers build more scalable, GUI tools Overview:
secure, and performant applications.
There are several GUI tools available for MongoDB that provide a graphical user interface
Create MongoDB Atlas Cluster: for managing and interacting with MongoDB databases. Here are a few popular options:
1. MongoDB Compass: MongoDB Compass is the official GUI for MongoDB. It provides a 3. Launch MongoDB Compass: Once you've installed MongoDB Compass, launch the
visual interface for managing databases, collections, and documents, as well as features application from your applications menu or desktop shortcut.
such as query analysis, aggregation pipeline visualization, and index optimization. MongoDB
Compass is available for free and can be downloaded from the MongoDB website. 4. Connect to a MongoDB instance: To connect to a MongoDB instance, click the "New
Connection" button on the MongoDB Compass home screen. This will bring up the
2. Studio 3T: Studio 3T is a popular commercial GUI tool for MongoDB that provides connection settings dialog.
features such as SQL querying, visual schema design, and data import/export. It also
includes a variety of productivity tools such as code generation, aggregation pipeline 5. Configure connection settings: In the connection settings dialog, enter the connection
building, and regular expression testing. details for your MongoDB instance, including the hostname, port number, and
authentication details if necessary. You can also configure additional options such as SSL
3. Robo 3T: Robo 3T is a free and open-source GUI for MongoDB that provides a simple and encryption and SSH tunneling if needed.
lightweight interface for managing databases and collections. It includes features such as
querying, indexing, and data export/import. 6. Test the connection: Once you've configured your connection settings, click the
"Connect" button to test the connection. If the connection is successful, you'll be able to
4. NoSQLBooster: NoSQLBooster is a commercial GUI tool for MongoDB that provides see a list of databases and collections in the left-hand navigation pane.
features such as smart query autocompletion, schema visualization, and aggregation
pipeline building. It also includes a variety of productivity tools such as data generation, 7. Explore data with MongoDB Compass: With MongoDB Compass connected to your
code generation, and document comparison. MongoDB instance, you can explore your data using the intuitive GUI interface. You can
view documents, create new documents, run queries, and perform other actions on your
5. Aqua Data Studio: Aqua Data Studio is a commercial multi-database GUI tool that MongoDB data.
supports MongoDB as well as other database systems. It includes features such as visual
query builder, schema synchronization, and data import/export. That's it! With MongoDB Compass installed and connected to your MongoDB instance, you
can manage your databases and collections with ease.
These GUI tools provide a convenient and user-friendly way to manage MongoDB databases
and perform various tasks such as querying, indexing, and data manipulation. Introduction to the MongoDB Shell:

Install and Configure MongoDB Compass: The MongoDB shell is a command-line interface for interacting with MongoDB databases.
It's a powerful tool that allows you to manage your databases, collections, and documents
Sure, here are the steps to install and configure MongoDB Compass: using a simple yet flexible syntax.

1. Download MongoDB Compass: Go to the MongoDB Compass website To launch the MongoDB shell, you can simply open a terminal or command prompt and
(https://www.mongodb.com/products/compass) and download the version of MongoDB type `mongo`. This will start the shell and connect you to the default MongoDB instance
Compass that's appropriate for your operating system. running on your local machine.

2. Install MongoDB Compass: Run the installer and follow the prompts to install MongoDB Once you're connected to the shell, you can perform a variety of tasks such as:
Compass on your computer.
1. Creating and managing databases and collections The MongoDB shell uses a JavaScript engine to execute commands and interact with the
database. The default JavaScript engine used by MongoDB is V8, which is also used by the
2. Inserting, updating, and deleting documents Google Chrome browser and Node.js.
3. Running queries and aggregations This means that you can use all of the features of the JavaScript language when working
with the MongoDB shell. For example, you can define variables, use loops and conditional
4. Managing indexes and backups
statements, and even define functions to perform more complex operations.

Here's an example of using a loop and a conditional statement in the MongoDB shell to
The MongoDB shell uses a JavaScript-based syntax, which means that you can write scripts update multiple documents in a collection:
and functions to automate common tasks and perform more complex operations.
var collection = db.getCollection("mycollection");
Here are a few basic commands to get you started with the MongoDB shell:
// Get all documents where the "status" field is "active"
1. `show dbs`: Show a list of all databases on the current MongoDB instance.
var documents = collection.find({ "status": "active" });
2. `use <database>`: Switch to the specified database.
// Loop through each document and update the "status" field to "inactive"
3. `db.createCollection("<collection>")`: Create a new collection in the current database.
documents.forEach(function(doc) {
4. `db.<collection>.insertOne(<document>)`: Insert a new document into the specified
collection.updateOne(
collection.
{ "_id": doc._id },
5. `db.<collection>.find()`: Retrieve all documents from the specified collection.
{ "$set": { "status": "inactive" } }
6. `db.<collection>.updateOne(<filter>, <update>)`: Update the first document that
matches the specified filter in the specified collection. );
7. `db.<collection>.deleteOne(<filter>)`: Delete the first document that matches the });
specified filter in the specified collection.
In this example, we're using the `find()` method to retrieve all documents in the
These are just a few examples of the many commands available in the MongoDB shell. With "mycollection" collection where the "status" field is set to "active". We then loop through
some practice and experimentation, you can become proficient at using the shell to manage each document using the `forEach()` method, and update the "status" field to "inactive"
your MongoDB databases and collections. using the `updateOne()` method.

MongoDB Shell JavaScript Engine: This is just a simple example, but the MongoDB shell and its JavaScript engine allow you to
perform much more complex operations and queries. With some practice and
experimentation, you can become proficient at using the shell to manage your MongoDB 4. Functions: You can define and use functions to perform more complex operations. For
databases and collections. example:

MongoDB Shell JavaScript Syntax: function add(x, y) {

The MongoDB shell uses a JavaScript-based syntax for executing commands and interacting return x + y;
with the database. This means that you can use all of the features of the JavaScript
}
language when working with MongoDB, including variables, loops, conditional statements,
and functions. var result = add(3, 4);
Here are some basic examples of the JavaScript syntax used in the MongoDB shell: print(result); // prints 7
1. Variables: You can define variables using the `var` keyword. For example: These are just a few examples of the JavaScript syntax used in the MongoDB shell. With
some practice and experimentation, you can become proficient at using the shell to manage
var x = 5;
your MongoDB databases and collections.
2. Loops: You can use loops like `for` and `while` to iterate over data. For example:
Introduction to the MongoDB Data Types:
for (var i = 0; i < 10; i++) {
MongoDB supports a wide range of data types that you can use to store and manipulate
print(i); data in your databases. Here's an overview of the most commonly used MongoDB data
types:
}
1. String: A sequence of UTF-8 characters, used to represent text. Strings are enclosed in
3. Conditional statements: You can use `if` and `else` statements to perform conditional double quotes (").
logic. For example:
2. Number: A numeric value, either an integer or a floating-point number. MongoDB
var x = 5; supports several types of number, including 32-bit and 64-bit integers, and 64-bit floating-
point numbers.
if (x > 10) {
3. Boolean: A value that is either true or false.
print("x is greater than 10");
4. Date: A date and time value, represented as a 64-bit integer that stores the number of
} else {
milliseconds since the Unix epoch (January 1, 1970).
print("x is less than or equal to 10");
5. Object: A nested document that can contain other fields and values.
}
6. Array: An ordered list of values, represented as a nested document with integer keys.
7. ObjectId: A unique identifier for a document, automatically generated by MongoDB. db.myCollection.updateOne({ name: "John" }, { $set: { age: 35 } });
ObjectId values are 12-byte binary values that include a timestamp, a machine identifier, a
process identifier, and a counter. This will update the `age` field of the first document in the `myCollection` collection that has
a `name` field equal to "John" to 35.
8. Binary data: A binary value, used to represent arbitrary data such as images or audio
files. 4. Delete: To remove documents from MongoDB, you can use the `deleteOne` or
`deleteMany` method. For example:
9. Regular expression: A pattern used to match text, represented as a string with optional
flags. db.myCollection.deleteOne({ name: "John" });

10. Null: A value that represents the absence of a value. This will delete the first document in the `myCollection` collection that has a `name` field
equal to "John".
These data types can be used in a variety of ways in MongoDB, and you can also create your
own custom data types using MongoDB's flexible schema design capabilities. These are the basic CRUD operations that you can perform on documents in MongoDB.
With these operations, you can manage your data and collections in a flexible and powerful
Introduction to the CRUD Operations on documents: way.

CRUD stands for Create, Read, Update, and Delete, and these are the basic operations that Create and Delete Databases and Collections:
you can perform on documents in MongoDB. Here's a brief overview of each operation:
In MongoDB, you can create and delete databases and collections using the following
1. Create: To create a new document in MongoDB, you can use the `insertOne` or commands:
`insertMany` method. For example:
1. Creating a database: To create a new database in MongoDB, you can use the `use`
db.myCollection.insertOne({ name: "John", age: 30 }); command followed by the name of the database. For example:

This will insert a new document with the `name` and `age` fields into the `myCollection` use myDatabase
collection.
This will create a new database called `myDatabase`. Note that this command does not
2. Read: To retrieve documents from MongoDB, you can use the `find` method. For actually create the database until you insert data into it.
example:
2. Creating a collection: To create a new collection in MongoDB, you can use the
db.myCollection.find({ name: "John" }); `createCollection` method. For example:

This will return all documents in the `myCollection` collection that have a `name` field equal db.createCollection("myCollection")
to "John".
This will create a new collection called `myCollection` in the current database.
3. Update: To update an existing document in MongoDB, you can use the `updateOne` or
`updateMany` method. For example: 3. Deleting a database: To delete a database in MongoDB, you can use the `dropDatabase`
method. For example:
 use myDatabase db.myCollection.find({ name: "John", age: { $gt: 30 } })

db.dropDatabase() This will return all documents in the `myCollection` collection that have a `name` field equal
to "John" and an `age` field greater than 30.
This will delete the `myDatabase` database and all its collections.
4. Sort the results of a query:
4. Deleting a collection: To delete a collection in MongoDB, you can use the `drop` method.
For example: db.myCollection.find().sort({ age: -1 })

db.myCollection.drop() This will return all documents in the `myCollection` collection sorted by the `age` field in
descending order.
This will delete the `myCollection` collection from the current database.
5. Limit the number of results:
Note that deleting a database or collection is a permanent operation, so be sure to use
these commands with caution. Also, keep in mind that dropping a collection does not delete db.myCollection.find().limit(10)
the data that was stored in it, so be sure to back up your data before deleting any
collections. This will return the first 10 documents in the `myCollection` collection.

These are just a few examples of the types of queries you can perform in MongoDB. With its
Introduction to MongoDB Queries:
flexible and powerful query language, you can retrieve data from your collections in a wide
In MongoDB, queries are used to retrieve data from a collection based on certain criteria. variety of ways.
MongoDB uses a powerful and flexible query language that allows you to filter, sort, and
limit the data returned by a query.

Here are some examples of basic queries in MongoDB:

1. Find all documents in a collection: THANK YOU

db.myCollection.find()
HAPPY LEARNING
This will return all documents in the `myCollection` collection.

2. Find documents that match a specific condition:

db.myCollection.find({ name: "John" })

This will return all documents in the `myCollection` collection that have a `name` field equal
to "John".

3. Find documents with multiple conditions: