### TypeScript Tutorial

---

## Table of Contents

1. **Introduction to TypeScript**

* What is TypeScript?
* Why Use TypeScript?

2. **Setting Up TypeScript**

* Installing TypeScript
* Basic Configuration
* Running TypeScript Code

3. **Basic Types in TypeScript**

* Primitive Types
* Arrays and Tuples
* Enums

4. **Variables, Constants, and Type Inference**

* `let` vs `const` vs `var`

* Type Inference
* Explicit Type Annotation

5. **Functions in TypeScript**

* Function Types
* Optional and Default Parameters
* Function Overloading

6. **Interfaces and Types**

* Interfaces vs Types
* Extending Interfaces
* Implementing Interfaces in Classes

7. **Classes and Object-Oriented Concepts**

* Basic Classes in TypeScript

* Inheritance
* Access Modifiers (`public`, `private`, `protected`)

8. **Generics**

* What are Generics?

* Generic Functions
* Generic Constraints

9. **Advanced TypeScript Concepts**

* Type Guards
* Union and Intersection Types
 * Literal Types
* Type Aliases

10. **Working with Asynchronous Code**

* Promises and Async/Await

* TypeScript and Fetch API

11. **Modules and Namespaces**

* Importing and Exporting

* ES6 Modules vs TypeScript Namespaces

12. **TypeScript Configuration**

* `[Link]`
* Compiler Options
* Strict Mode

13. **Debugging TypeScript**

* Source Maps
* Debugging in VSCode

14. **Conclusion**

* Recap of Key Points

* Further Resources

---

## 1. Introduction to TypeScript

### What is TypeScript?

TypeScript is a superset of JavaScript that adds static typing to the language.

This means you can define types for variables, functions, and objects, which helps
catch errors early during development. TypeScript compiles to plain JavaScript, so
it works seamlessly with existing JavaScript codebases.

### Why Use TypeScript?

TypeScript brings several benefits to developers:

* **Static Typing:** It helps detect errors during development, reducing the chance
of runtime errors.
* **Improved Tooling:** Better autocompletion, refactoring tools, and IDE support.
* **Better Readability and Maintainability:** Explicit types make the code easier
to understand and maintain.
* **Large-scale Application Support:** TypeScript is ideal for large codebases, as
it provides strong typing to manage complexity.

---

## 2. Setting Up TypeScript

### Installing TypeScript

To get started with TypeScript, first, you need to install the TypeScript compiler
(`tsc`):

```bash
npm install -g typescript
```

### Basic Configuration

You can configure TypeScript using the `[Link]` file. To generate this file,
use:

```bash
tsc --init
```

This creates a default configuration file that you can modify according to your
needs.

### Running TypeScript Code

After installing TypeScript, you can write `.ts` files and compile them to
JavaScript using:

```bash
tsc [Link]
```

This generates a `[Link]` file, which you can run with [Link]:

```bash
node [Link]
```

---

## 3. Basic Types in TypeScript

### Primitive Types

TypeScript supports several primitive types:

* `number`: Represents numeric values.

* `string`: Represents string values.
* `boolean`: Represents `true` or `false`.

```typescript
let age: number = 25;
let name: string = "Alice";
let isActive: boolean = true;
```

### Arrays and Tuples

Arrays in TypeScript can be typed as follows:

```typescript
let numbers: number[] = [1, 2, 3];
let strings: Array<string> = ["a", "b", "c"];
```
Tuples are ordered collections with fixed types:

```typescript
let person: [string, number] = ["Alice", 25];
```

### Enums

Enums allow you to define a set of named constants:

```typescript
enum Direction {
Up,
Down,
Left,
Right
}

let move: Direction = [Link];

```

---

## 4. Variables, Constants, and Type Inference

### `let` vs `const` vs `var`

* `let` allows you to reassign a variable.

* `const` is used for variables that should not be reassigned.
* `var` is function-scoped, but `let` and `const` are block-scoped.

### Type Inference

TypeScript often infers the type of a variable based on the value assigned to it:

```typescript
let age = 25; // TypeScript infers age as number
```

### Explicit Type Annotation

You can explicitly declare types:

```typescript
let name: string = "Alice";
```

---

## 5. Functions in TypeScript

### Function Types

In TypeScript, functions can be typed explicitly:

```typescript
function greet(name: string): string {
return "Hello " + name;
}
```

### Optional and Default Parameters

You can define optional parameters with a `?` and default parameters:

```typescript
function greet(name: string, age?: number): string {
return age ? `Hello ${name}, you are ${age} years old` : `Hello ${name}`;
}

function multiply(a: number, b: number = 2): number {

return a * b;
}
```

### Function Overloading

TypeScript allows function overloading, meaning you can define multiple function
signatures:

```typescript
function greet(person: string): string;
function greet(person: string, age: number): string;
function greet(person: string, age?: number): string {
return age ? `Hello ${person}, you are ${age}` : `Hello ${person}`;
}
```

---

## 6. Interfaces and Types

### Interfaces vs Types

* **Interfaces** define the structure of an object, such as properties and methods.

* **Types** can be used to define any type, including primitive types, objects, or
even functions.

```typescript
interface Person {
name: string;
age: number;
}

type PersonType = {
name: string;
age: number;
};
```

### Extending Interfaces

Interfaces can extend other interfaces:

```typescript
interface Employee extends Person {
role: string;
}
```

### Implementing Interfaces in Classes

Classes can implement interfaces to ensure they adhere to the structure:

```typescript
class Developer implements Person {
constructor(public name: string, public age: number) {}
}
```

---

## 7. Classes and Object-Oriented Concepts

### Basic Classes in TypeScript

Classes in TypeScript are similar to JavaScript but with added type support:

```typescript
class Car {
make: string;
model: string;

constructor(make: string, model: string) {

[Link] = make;
[Link] = model;
}

display(): string {
return `Car: ${[Link]} ${[Link]}`;
}
}
```

### Inheritance

Classes can inherit properties and methods from other classes:

```typescript
class ElectricCar extends Car {
batteryLife: number;

constructor(make: string, model: string, batteryLife: number) {

super(make, model);
[Link] = batteryLife;
}
}
```

### Access Modifiers

TypeScript provides three access modifiers for class members:

* `public`: Default modifier, accessible everywhere.

* `private`: Can only be accessed within the class.
* `protected`: Can be accessed within the class and its subclasses.
```typescript
class Person {
private name: string;
protected age: number;

constructor(name: string, age: number) {

[Link] = name;
[Link] = age;
}
}
```

---

## 8. Generics

### What are Generics?

Generics allow you to write functions and classes that work with any type, but
still retain type safety:

```typescript
function identity<T>(value: T): T {
return value;
}

let result = identity(5); // TypeScript infers T as number

```

### Generic Functions

You can use generics in functions to create flexible APIs:

```typescript
function merge<T, U>(obj1: T, obj2: U): T & U {
return { ...obj1, ...obj2 };
}
```

### Generic Constraints

You can constrain the types of generics:

```typescript
function lengthOf<T extends { length: number }>(value: T): number {
return [Link];
}
```

---

## 9. Advanced TypeScript Concepts

### Type Guards

Type guards help you narrow down types in conditionals:

```typescript
function isString(value: any): value is string {
return typeof value === "string";
}

if (isString(value)) {
[Link]([Link]); // Safe to access string methods
}
```

### Union and Intersection Types

* **Union Types** allow a variable to be one of several types.

* **Intersection Types** combine multiple types into one.

```typescript
let value: string | number = "hello";
let person: { name: string } & { age: number } = { name: "
```