Chapter 3: एडवांस्ड टाइप्स (Advanced Types)

interface Person {
    name: string;
    age: number;
    isStudent?: boolean; // Optional property
}

interface Person {
    name: string;
    age: number;
    isStudent?: boolean;
}

let person: Person = {
    name: "Daniel",
    age: 30
};

console.log(person.name); // Daniel
console.log(person.age); // 30

interface Greet {
    (name: string, greeting: string): string;
}

const greet: Greet = (name: string, greeting: string) => {
    return `${greeting}, ${name}!`;
}

console.log(greet("Daniel", "Hello")); // Hello, Daniel!

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

interface Student extends Person {
    grade: string;
}

let student: Student = {
    name: "Mateo",
    age: 8,
    grade: "3rd"
};

console.log(student.name); // Mateo
console.log(student.age); // 8
console.log(student.grade); // 3rd

interface Person {
    name: string;
    age: number;
    greet(): string;
}

class Student implements Person {
    name: string;
    age: number;
    grade: string;

    constructor(name: string, age: number, grade: string) {
    	this.name = name;
    	this.age = age;
    	this.grade = grade;
    }

    greet(): string {
    	return `Hello, my name is ${this.name} and I am in grade ${this.grade}.`;
    }
}

let student = new Student("Mateo", 8, "3rd");
console.log(student.greet()); // Hello, my name is Mateo and I am in grade 3rd.

class Person {
    name: string;
    age: number;

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

    greet(): string {
    	return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

let person = new Person("Daniel", 30);
console.log(person.greet()); // Hello, my name is Daniel and I am 30 years old.

class Person {
    public name: string;
    public age: number;

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

    public greet(): string {
    	return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

let person = new Person("Daniel", 30);
console.log(person.greet()); // Hello, my name is Daniel and I am 30 years old.

class Person {
    private name: string;
    private age: number;

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

    public greet(): string {
    	return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

let person = new Person("Daniel", 30);
// console.log(person.name); // Error: Property 'name' is private and only accessible within class 'Person'.
console.log(person.greet()); // Hello, my name is Daniel and I am 30 years old.


2.3 protected
protected प्रॉपर्टीज और मेथड्स को क्लास और उसकी सब-क्लासेस के भीतर से एक्सेस किया जा सकता है।
class Person {
    protected name: string;
    protected age: number;

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

class Student extends Person {
    private grade: string;

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

    public introduce(): string {
    	return `Hello, my name is ${this.name}, I am ${this.age} years old and I am in grade ${this.grade}.`;
    }
}

let student = new Student("Mateo", 8, "3rd");
console.log(student.introduce()); // Hello, my name is Mateo, I am 8 years old and I am in grade 3rd.

class Person {
    name: string;
    age: number;

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

    greet(): string {
    	return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

class Student extends Person {
    grade: string;

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

    introduce(): string {
    	return `Hello, my name is ${this.name}, I am ${this.age} years old and I am in grade ${this.grade}.`;
    }
}

let student = new Student("Mateo", 8, "3rd");
console.log(student.introduce()); // Hello, my name is Mateo, I am 8 years old and I am in grade 3rd.

class MathUtil {
    static PI: number = 3.14;

    static calculateCircumference(diameter: number): number {
    	return this.PI * diameter;
    }
}

console.log(MathUtil.PI); // 3.14
console.log(MathUtil.calculateCircumference(10)); // 31.4

function identity<T>(arg: T): T {
    return arg;
}

let output1 = identity<string>("Hello, TypeScript!");
let output2 = identity<number>(100);

console.log(output1); // Hello, TypeScript!
console.log(output2); // 100

function echo<T>(value: T): T {
    return value;
}

console.log(echo<string>("TypeScript")); // TypeScript
console.log(echo<number>(123)); // 123

2.2 जेनरिक फंक्शन में मल्टीपल टाइप पैरामीटर्स (Multiple Type Parameters in Generic Function)

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

let mergedObject = merge({ name: "Daniel" }, { age: 30 });
console.log(mergedObject); // { name: "Daniel", age: 30 }

class Box<T> {
    contents: T;

    constructor(value: T) {
    	this.contents = value;
    }

    getContents(): T {
    	return this.contents;
    }
}

let stringBox = new Box<string>("Hello");
let numberBox = new Box<number>(123);

console.log(stringBox.getContents()); // Hello
console.log(numberBox.getContents()); // 123

interface Pair<T, U> {
    key: T;
    value: U;
}

let stringNumberPair: Pair<string, number> = { key: "Age", value: 30 };
let numberBooleanPair: Pair<number, boolean> = { key: 1, value: true };

console.log(stringNumberPair); // { key: "Age", value: 30 }
console.log(numberBooleanPair); // { key: 1, value: true }

interface HasLength {
    length: number;
}

function logLength<T extends HasLength>(arg: T): void {
    console.log(arg.length);
}

logLength("Hello"); // 5
logLength([1, 2, 3, 4]); // 4
// logLength(123); // Error: Argument of type 'number' is not assignable to parameter of type 'HasLength'.