Interface in TypeScript :Explained

interface User {
    name: string;
    age: number;
    email: string;
}
const user: User = {
    name: "Alice",
    age: 30,
    email: "alice@example.com",
};   

interface Point {
    x: number;
    y: number;
}
function printPoint(point: Point) {
    console.log(`X: ${point.x}, Y: ${point.y}`);
}
printPoint({ x: 10, y: 20 }); // Type-checked against the Point interface

interface Animal {
    name: string;
    speak(): void;
}
class Dog implements Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    speak(): void {
        console.log(`${this.name} barks`);
    }
}
// Example usage:
const dog = new Dog("Buddy");
dog.speak()

interface Flyer {
    fly(): void;
}
function launch(flyer: Flyer) {
    flyer.fly(); // Works with any object implementing the "fly" method
}
class Bird implements Flyer {
    fly() {
        console.log("Flap, flap!");
    }
}
// Works as expected
launch(new Bird());

const plane: Flyer = { 
    fly: () => console.log("Zoom!") 
};
// Works with a plain object that matches the Flyer interface
launch(plane); 

interface MathOperation {
    (a: number, b: number): number; // Type signature for a function taking two numbers and returning a number
}

const add: MathOperation = (a, b) => a + b; // Function implementing the MathOperation interface
const multiply: MathOperation = (a, b) => a * b; // Another function adhering to the interface

const result = add(5, 3); // Works as expected, result is 8
console.log("Addition Result:", result);

function performOperation(op: MathOperation, x: number, y: number): number {
    return op(x, y); // Function accepting any function conforming to the MathOperation interface
}

const product = performOperation(multiply, 2, 4); // Uses multiply function with performOperation
console.log("Multiplication Result:", product);

interface User {
    name: string; // Required property
    age?: number; // Optional property
    bio?: string; // Another optional property
}

const user1: User = { name: "Alice", age: 30 }; // Fulfills both required and optional properties
const user2: User = { name: "Bob" }; // Fulfills only the required property (age and bio omitted)

function displayUserInfo(user: User): void {
    console.log(`Name: ${user.name}`);
    if (user.age !== undefined) {
        console.log(`Age: ${user.age}`); // Safe check for optional property
    }
    if (user.bio !== undefined) {
        console.log(`Bio: ${user.bio}`); // Additional check for another optional property
    }
}

// Display information for both users
displayUserInfo(user1); // Prints name and age
displayUserInfo(user2); // Prints only the name 

interface Product {
    readonly id: string; // Read-only property (cannot be changed)
    name: string; // Regular property (can be updated)
    price: number; // Regular property
}

const shirt: Product = { 
    id: "ABC123", 
    name: "T-shirt", 
    price: 20 
};

// Can update regular properties:
shirt.name = "Polo shirt";
shirt.price = 25;

// Cannot directly modify read-only property:
// This line would raise an error: 
// shirt.id = "XYZ456"; // Uncommenting this line will throw a TypeScript error

// Allowed only through creating a new object:
const newShirt = Object.assign({}, shirt, { id: "XYZ456" });

console.log("Updated shirt:", shirt); 
console.log("New shirt:", newShirt);

interface StringMap {
    [key: string]: number; // Allows any string key with a number value
}

const employeeData: StringMap = {
    age: 30,
    salary: 50000,
    performanceBonus: 1000, // Added this for better compliance with type safety
};

// Accessing data by string key
const employeeAge = employeeData["age"]; // Accessing age by key
console.log("Employee Age:", employeeAge);

// Adding a new key-value pair with a dynamic key
const bonusKey = "performanceBonus";
employeeData[bonusKey] = 1500; // Updating the performance bonus
console.log("Updated Performance Bonus:", employeeData[bonusKey]);

// Printing the entire object
console.log("Employee Data:", employeeData); 

interface MathOperation {
    add(a: number, b: number): number; // Function signature for 'add' with two number params and a number return
    multiply?: (a: number, b: number) => number; // Optional function signature for 'multiply' with the same types
}

const calculator: MathOperation = {
    add(a, b) {
        return a + b;
    },
    // No need to define 'multiply' initially, as it's optional
};

const sum = calculator.add(5, 3); // Works as expected (5 + 3 = 8)
console.log("Sum:", sum);

// To add `multiply`, we need to use a new object with all properties merged:
const extendedCalculator: MathOperation = {
    ...calculator,
    multiply: (a, b) => a * b,
};

if (extendedCalculator.multiply) {
    const product = extendedCalculator.multiply(2, 4); // Now works (2 * 4 = 8)
    console.log("Product:", product);
}

interface Person {
    name: string;
    age: number;
    greet(): string; // Method signature with no arguments and a string return type
}
class Employee implements Person {
    name: string;
    age: number;
    department: string; // Additional property not defined in the interface
    constructor(name: string, age: number, department: string) {
        this.name = name;
        this.age = age;
        this.department = department;
    }
    greet(): string {
        return `Hello, my name is ${this.name} and I work in the ${this.department} department.`;
    }
}
const john = new Employee("John Doe", 30, "Engineering");
console.log(john.greet()); // Prints "Hello, my name is John Doe and I work in the Engineering department."

interface Person {
    name: string;
    age: number;
}
interface Employee extends Person {
    department: string;
    work(): string; // Additional method specific to Employee
}
const john: Employee = {
    name: "John Doe",
    age: 30,
    department: "Engineering",
    work() {
        return "I'm coding in TypeScript!";
    },
};

console.log(john.name); // Accesses inherited property from Person
console.log(john.work()); // Uses method specific to Employee