Type Guards In Typescript In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

Type Guards वो functions या techniques होते हैं जो TypeScript को बताते हैं कि कोई particular variable या value किस type का है।

यह runtime पर काम करते हैं, और TypeScript को इस बात का confidence देते हैं कि आगे का code कौनसा type handle कर रहा है।

Type Guards कि help से हम TypeScript को यह समझाते हैं कि -

• अगर यह condition true है, तो इस variable का type क्या है।

• और अगर यह condition false है, तो उसका type क्या नहीं है।

●●●

Type Guards Syntax

चलिए हम basic syntax से शुरू करते हैं। सबसे common type guard एक typeof या instanceof check होता है।

typeof Operator

typeof operator का use primitive types जैसे string, number, boolean, etc. को check करने के लिए होता है।

Copy
function printType(value: string | number) {
    if (typeof value === 'string') {
        console.log(`This is a string: ${value}`);
    } else {
        console.log(`This is a number: ${value}`);
    }
}

यहां पर, TypeScript को typeof कि help से पता लगता है कि variable value string है या number, और उसके accordingly proper code execute होता है।

instanceof Operator

instanceof का use class instances को check करने के लिए होता है।

Copy
class Dog {
    bark() {
        console.log("Woof Woof");
    }
}

class Cat {
    meow() {
        console.log("Meow Meow");
    }
}

function animalSound(animal: Dog | Cat) {
    if (animal instanceof Dog) {
        animal.bark();  // TypeScript knows it's a Dog here
    } else {
        animal.meow();  // TypeScript knows it's a Cat here
    }
}

इस example में, animal object Dog या Cat का instance है, और instanceof operator TypeScript को बताता है कि किस type का instance use हो रहा है, ताकि हम correct method call कर सकें।

●●●

Custom Type Guards

कई बार ऐसे complex types होते हैं जहाँ typeof और instanceof sufficient नहीं होते। ऐसे में हमें custom type guards लिखने पड़ते हैं।

यह functions होते हैं जो specific type checking करते हैं और TypeScript को बताते हैं कि अगर यह function true return करे, तो variable का type क्या है।

Custom Type Guard Syntax

Copy
function isDog(animal: any): animal is Dog {
    return (animal as Dog).bark !== undefined;
}

यहां पर isDog() एक custom type guard function है। animal is Dog यह बताता है कि अगर function true return करे, तो animal का type Dog है।

Example

Copy
function makeSound(animal: Dog | Cat) {
    if (isDog(animal)) {
        animal.bark();  // TypeScript knows it's a Dog
    } else {
        animal.meow();  // TypeScript knows it's a Cat
    }
}

यहां isDog type guard कि वजह से TypeScript confidently animal.bark() को call करता है, क्योंकि उससे पता होता है कि अब animal Dog है।

●●●

TypeScript in Operator

TypeScript में in operator का use भी type guards के लिए होता है , यह check करता है कि क्या कोई property किसी object में exist करती है या नहीं।

Copy
interface Car {
    drive(): void;
}

interface Boat {
    sail(): void;
}

function move(vehicle: Car | Boat) {
    if ('drive' in vehicle) {
        vehicle.drive();  // TypeScript knows it's a Car
    } else {
        vehicle.sail();   // TypeScript knows it's a Boat
    }
}

इस example में, drive property का check TypeScript को बताता है कि vehicle का type Car है, और अगर यह property नहीं मिलती, तो TypeScript समझता है कि vehicle Boat है।

●●●

Type Guards with Unions and Intersections

TypeScript में type guards काफी useful होते हैं जब हम union types या intersection types के साथ काम कर रहे होते हैं।

Union Types का मतलब होता है कि एक variable multiple types को hold कर सकता है , और हम type guards कि help से उस particular type को check कर सकते हैं।

Example

Copy
function formatInput(input: string | number) {
    if (typeof input === 'string') {
        return input.toUpperCase();  // It's a string
    } else {
        return input.toFixed(2);     // It's a number
    }
}

Intersection Types का मतलब है कि एक variable multiple types का combination हो सकता है, और हमें दोनो types को handle करना पड़ता है।

Example

Copy
interface Name {
    name: string;
}

interface Age {
    age: number;
}

type Person = Name & Age;

function printPerson(person: Person) {
    console.log(`${person.name} is ${person.age} years old`);
}

यहां, Person type guard नहीं लगता , क्योंकि intersection types में दोनो types present होते हैं, लेकिन अगर complex logic हो तो type guards कि need हो सकती है।

●●●

Real-World Example of Type Guards

अब हम एक real-world scenario देखते हैं, जहाँ type guards useful होते हैं -

Copy
interface Admin {
    role: 'admin';
    permissions: string[];
}

interface User {
    role: 'user';
    accessLevel: number;
}

function getDashboard(user: Admin | User) {
    if (user.role === 'admin') {
        console.log(`Admin permissions: ${user.permissions.join(", ")}`);
    } else {
        console.log(`User access level: ${user.accessLevel}`);
    }
}

इस case में, role की help से हम user का type check कर रहे हैं, और उसके हिसाब से appropriate properties access कर रहे हैं।

●●●

Conclusion

TypeScript Type Guards एक powerful feature है जो आपको dynamic types को handle करने में help देते हैं। यह न सिर्फ आपके code को safe बनाते हैं, बल्कि आपको better type inference और error detection provide करते हैं।

Custom type guards और built-in operators जैसे typeof, instanceof, और इन के साथ, आप अपनी applications में complex type checking को काफी smoothly handle कर सकते हैं।

आपके code को clean और maintainable बनाने के लिए Type Guards का use जरूर करें, ताकि आपकी application के types और behavior predictably काम कर सकें।