TypeScript
कक्षाएं

परिचय

साधारण वर्ग

class Car {
    public position: number = 0;
    private speed: number = 42;
    
    move() {
        this.position += this.speed;
    }
}    

इस उदाहरण में, हम एक साधारण श्रेणी की Car घोषित करते हैं। एक निजी संपत्ति: कक्षा तीन सदस्य हैं speed , एक सार्वजनिक संपत्ति position और एक सार्वजनिक विधि move । ध्यान दें कि प्रत्येक सदस्य डिफ़ॉल्ट रूप से सार्वजनिक है। इसलिए move() सार्वजनिक है, भले ही हमने public कीवर्ड का उपयोग नहीं किया हो।

var car = new Car();        // create an instance of Car
car.move();                 // call a method
console.log(car.position);  // access a public property

मूल वंशानुक्रम

class Car {
    public position: number = 0;
    protected speed: number = 42;
    
    move() {
        this.position += this.speed;
    }
}  

class SelfDrivingCar extends Car {

    move() {
        // start moving around :-)
        super.move();
        super.move();
    }
}

यह उदाहरण दिखाता है कि extends कीवर्ड का उपयोग करके Car वर्ग का एक बहुत ही सरल उपवर्ग कैसे बनाया जाए। SelfDrivingCar वर्ग move() विधि को ओवरराइड करता है और super का उपयोग करके बेस क्लास कार्यान्वयन का उपयोग करता है।

कंस्ट्रक्टर्स

इस उदाहरण में हम बेस क्लास में सार्वजनिक संपत्ति की position और संरक्षित संपत्ति की speed को घोषित करने के लिए constructor का उपयोग करते हैं। इन गुणों को पैरामीटर गुण कहा जाता है। वे हमें एक जगह एक निर्माण पैरामीटर और एक सदस्य घोषित करते हैं।

टाइपस्क्रिप्ट में सबसे अच्छी चीजों में से एक, प्रासंगिक संपत्ति के लिए निर्माता मापदंडों का स्वचालित असाइनमेंट है।

class Car {
    public position: number;        
    protected speed: number;

    constructor(position: number, speed: number) {
        this.position = position;
        this.speed = speed;
    }
    
    move() {
        this.position += this.speed;
    }        
}

यह सभी कोड एक ही निर्माता में फिर से शुरू किए जा सकते हैं:

class Car {
    constructor(public position: number, protected speed: number) {}
    
    move() {
        this.position += this.speed;
    }        
}

और उन दोनों को टाइपस्क्रिप्ट (डिजाइन समय और संकलन समय) से जावास्क्रिप्ट में एक ही परिणाम के साथ स्थानांतरित किया जाएगा, लेकिन कोड कम लिखना:

var Car = (function () {
    function Car(position, speed) {
        this.position = position;
        this.speed = speed;
    }
    Car.prototype.move = function () {
        this.position += this.speed;
    };
    return Car;
}());

व्युत्पन्न वर्गों के रचनाकारों को बेस क्लास कंस्ट्रक्टर को super() साथ कॉल करना होगा।

class SelfDrivingCar extends Car {
    constructor(startAutoPilot: boolean) {
        super(0, 42);
        if (startAutoPilot) {
            this.move();
        }
    }
}

let car = new SelfDrivingCar(true);
console.log(car.position);  // access the public property position

पहुंचकर्ता

इस उदाहरण में, हम "सरल वर्ग" उदाहरण को संशोधित करते हैं ताकि speed संपत्ति तक पहुंच की अनुमति मिल सके। टाइपस्क्रिप्ट एक्सेसर्स हमें गेटर्स या सेटर में अतिरिक्त कोड जोड़ने की अनुमति देते हैं।

class Car {
    public position: number = 0;
    private _speed: number = 42;
    private _MAX_SPEED = 100
    
    move() {
        this.position += this._speed;
    }
    
    get speed(): number {
        return this._speed;
    }

    set speed(value: number) {
        this._speed = Math.min(value, this._MAX_SPEED);
    }
}

let car = new Car();
car.speed = 120;
console.log(car.speed);  // 100

सार वर्ग

abstract class Machine {
    constructor(public manufacturer: string) {
    }

    // An abstract class can define methods of it's own, or...
    summary(): string {
        return `${this.manufacturer} makes this machine.`;
    }
    
    // Require inheriting classes to implement methods
    abstract moreInfo(): string;
}

class Car extends Machine {
    constructor(manufacturer: string, public position: number, protected speed: number) {
        super(manufacturer);
    }
    
    move() {
        this.position += this.speed;
    }
    
    moreInfo() {
        return `This is a car located at ${this.position} and going ${this.speed}mph!`;
    }
}

let myCar = new Car("Konda", 10, 70);
myCar.move(); // position is now 80
console.log(myCar.summary()); // prints "Konda makes this machine."
console.log(myCar.moreInfo()); // prints "This is a car located at 80 and going 70mph!"

अमूर्त वर्ग आधार वर्ग होते हैं जिनसे अन्य वर्ग विस्तार कर सकते हैं। वे स्वयं को त्वरित नहीं कर सकते (अर्थात आप new Machine("Konda") नहीं कर सकते हैं )।

टाइपस्क्रिप्ट में एक सार वर्ग की दो प्रमुख विशेषताएं हैं:

1. वे अपने स्वयं के तरीकों को लागू कर सकते हैं।
2. वे उन तरीकों को परिभाषित कर सकते हैं जो विरासत में मिली कक्षाओं को लागू करना चाहिए ।

इस कारण से, अमूर्त वर्ग को वैचारिक रूप से एक इंटरफ़ेस और एक वर्ग का संयोजन माना जा सकता है।

बंदर एक मौजूदा कक्षा में एक समारोह पैच

कभी-कभी नए कार्यों के साथ कक्षा का विस्तार करने में सक्षम होना उपयोगी होता है। उदाहरण के लिए मान लीजिए कि एक स्ट्रिंग को ऊंट केस स्ट्रिंग में परिवर्तित किया जाना चाहिए। इसलिए हमें टाइपस्क्रिप्ट को बताने की आवश्यकता है, कि String में एक समारोह है, जिसे toCamelCase कहा जाता है, जो एक string लौटाता है।

interface String {
    toCamelCase(): string;
}

अब हम इस फ़ंक्शन को String कार्यान्वयन में पैच कर सकते हैं।

String.prototype.toCamelCase = function() : string {
    return this.replace(/[^a-z ]/ig, '')
        .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match: any, index: number) => {
            return +match === 0 ? "" : match[index === 0 ? 'toLowerCase' : 'toUpperCase']();
        });
}

यदि String का यह एक्सटेंशन लोड किया गया है, तो यह इस तरह उपयोग करने योग्य है:

"This is an example".toCamelCase();    // => "thisIsAnExample"

Transpilation

एक वर्ग को देखते हुए SomeClass , चलो देखते हैं कि कैसे टाइपप्रति जावास्क्रिप्ट में transpiled रहा है।

टाइपस्क्रिप्ट स्रोत

class SomeClass {

    public static SomeStaticValue: string = "hello";
    public someMemberValue: number = 15;
    private somePrivateValue: boolean = false;

    constructor () {
        SomeClass.SomeStaticValue = SomeClass.getGoodbye();
        this.someMemberValue = this.getFortyTwo();
        this.somePrivateValue = this.getTrue();
    }

    public static getGoodbye(): string {
        return "goodbye!";
    }

    public getFortyTwo(): number {
        return 42;
    }

    private getTrue(): boolean {
        return true;
    }

}

जावास्क्रिप्ट स्रोत

टाइपस्क्रिप्ट v2.2.2 का उपयोग करते समय, आउटपुट ऐसा होता है:

var SomeClass = (function () {
    function SomeClass() {
        this.someMemberValue = 15;
        this.somePrivateValue = false;
        SomeClass.SomeStaticValue = SomeClass.getGoodbye();
        this.someMemberValue = this.getFortyTwo();
        this.somePrivateValue = this.getTrue();
    }
    SomeClass.getGoodbye = function () {
        return "goodbye!";
    };
    SomeClass.prototype.getFortyTwo = function () {
        return 42;
    };
    SomeClass.prototype.getTrue = function () {
        return true;
    };
    return SomeClass;
}());
SomeClass.SomeStaticValue = "hello";

टिप्पणियों

• वर्ग के प्रोटोटाइप के संशोधन को IIFE के अंदर लपेटा जाता है।
• सदस्य चर मुख्य वर्ग function अंदर परिभाषित किए गए हैं।
• स्थैतिक गुण सीधे क्लास ऑब्जेक्ट में जोड़े जाते हैं, जबकि उदाहरण गुण प्रोटोटाइप में जोड़े जाते हैं।